Linux Cubed Series 8: LINUX Games/Linux Cubed Series 8 - LINUX Games.iso/games/muds/pennmush.000/pennmush-1.50-p8-linux.tar/pennmush/game/txt/help.txt

Text File | 1993-04-15 | 193KB | 4,664 lines

& help
  This is the MUSH online help facility.

  Notes on help descriptions:
    [text] - Text enclosed in []'s is optional.  The []'s are never typed
                 in as part of the command.
      <parameter> - Information parameter for a command.  The <>'s are
                      never typed in as part of the command.

  Syntax of help command:
    help [<command>]

  To get a list of MUSH topics:
     help topics

  To get a list of MUSH Commands:
     help commands

  If there are any errors in the help text, please notify a wizard
  in the game, or send mail to [e-mail]

  All commands listed in this file might not apply to all mushes running
  this code.  This is because some of the commands/effects can be enabled or
  disabled by the site admin of your MUSH.  If a command is not available
  AND it is documented, ask your site admin why it isn't enabled.
  You may use the "@config" command to see the MUSH configuration.

& COMMANDS
  Help is available for the following MUSH Commands:

  brief          DOING          drop           examine        enter
  events         get            give           goto           kill
  leave          LOGOUT         look           move           news
  page           pose           QUIT           read           rpage
  RWHO           say            score          slay           take
  think          use            whisper        WHO
  "              :              ;              &              +

  In addition to these, there are '@' commands.  @-commands usually are
  commands which can modify and affect the database in substantial ways.
  There are several types of '@' commands. The following help entries
  list available '@' commands:

  @-ATTRIBUTES   @-BUILDING     @-GENERAL      @-WIZARD

& @-ATTRIBUTES
  '@' commands which are attribute-related set game-defined attributes.

  These are:
  @aahear        @aclone        @aconnect      @adeath        @adescribe
  @adisconnect   @aefail        @aenter        @afailure      @ahear
  @aleave        @amhear        @amove         @apayment      @asuccess
  @atport        @ause          @away          @charges       @cost
  @death         @describe      @drop          @ealias        @efail
  @enter         @failure       @filter        @haven         @idescribe
  @idle          @infilter      @inprefix      @lalias        @leave
  @listen        @move          @odeath        @odescribe     @odrop
  @oefail        @oenter        @ofailure      @oleave        @omove
  @opayment      @osuccess      @otport        @ouse          @oxenter
  @oxleave       @oxtport       @payment       @prefix        @runout
  @sex           @startup       @success       @tport         @use

& @-BUILDING
  These '@' commands are building related (they modify the database):

  @atrlock       @atrchown      @chown         @chzone        @clone
  @cpattr        @create        @destroy       @dig           @elock
  @eunlock       @link          @lock          @name          @nuke
  @open          @parent        @set           @ulock         @unlink
  @unlock        @uunlock       @wipe

& @-GENERAL
  These '@' commands are general utilities and programming commands:

  @@             @alias        @channel       @chat          @config
  @decompile     @doing         @dolist        @drain         @edit
  @emit          @entrances     @find          @force         @function
  @gedit     @grep        @halt          @lemit         @listmotd
  @mail          @map           @notify        @oemit         @password
  @pemit         @ps            @remit         @rwall         @rwallemit
  @rwallpose     @scan        @search        @select        @stats
  @sweep         @switch        @teleport      @trigger       @verb
  @version       @wait          @whereis       @zemit

& @-WIZARD
  These '@' commands are only usable by wizards or priviledged players:

  @allhalt       @allquota      @boot          @chownall      @chzoneall
  @comment       @dbck          @disable       @dump          @enable
  @fixdb         @hide          @kick          @motd          @newpassword
  @pcreate       @poll          @poor          @power         @purge
  @quota         @readcache     @rejectmotd    @shutdown      @squota
  @toad          @uptime        @wall          @wallemit      @wallpose
  @wizemit       @wizmotd       @wizpose       @wizwall

& topics
  Help available on the following Topics:

  ATTRIB-OWNERSHIP         ATTRIBUTES               BEING KILLED
  BOGUS COMMANDS           BOOLEAN VALUES           CHAT
  CONTROL                  DROP-TO                  ENACTOR
  EVALUATION           EXITS                    FAILURE
  FLAGS                    FUNCTIONS            GENDER
  HERE                     HOMES                    LINKING
  LISTENING                LISTS                    LOOPING
  MASTER ROOM              NON-STANDARD ATTRIBUTES  OBJECT PARENTS
  PARENT ROOMS             PUPPETS                  ROBBERY
  SACRIFICING              SEMAPHORES               SPOOFING
  STACK                    SUBSTITUTIONS            SUCCESS
  SWITCHES                 TYPES OF OBJECTS         VERBS
  ZONE MASTERS             ZONE OBJECTS

& SEMAPHORES
  SEMAPHORES

  Semaphores may be used for synchronizing complex objects or for enforcing
  mutual exclusion. Any object, of any type, that you control or that is
  LINK_OK can be used as a semaphore.

  The semaphore state of an object is shown by the SEMAPHORE attribute,
  which cannot be manually changed by mortals. A positive number indicates
  that there are that many commands awaiting "notifies" on the semaphore
  object; a negative number indicates that many waits on that semaphore
  will not block.

  The @wait command is used to queue commands on a semaphore, delaying
  them until the semaphore is notified with the "@notify" command.
  The @drain command and "@notify/all" clear the semaphore on the object,
  discarding and executing immediately all pending commands, respectively.
  The object which is doing the @wait executes the commands, NOT the
  semaphore.

  (See 'help semaphores2' for more)

& SEMAPHORES2
  You can also specify a timeout value for a semaphore wait with
  @wait <object>/<timeout> = <command>  (instead of the normal form
  of the semaphore wait command: @wait <object> = <command> )
  If the time period expires before the semaphore is notified, then
  the command is executed and the semaphore count decremented, just
  as if the command had been run because the semaphore was notified.

  Examples:

  > @wait semaphore=:tests.
  > @notify semaphore
  Wizard tests.

  > @wait timer/30=:waits 30 seconds.
  [ 30 seconds passes. ]
  Wizard waits 30 seconds.

  See also the help for: @wait, @drain, @notify
& SWITCHES
  SWITCHES

  Commands can have "switches" which modify the behavior of the
  command. Switches are attached after the end of a command.
  Most switches have a single-command short form; command switches
  are provided in this code to increase compatiblity with TinyMUSH 2.0,
  as well as to reduce the number of commadns that players need to
  remember.

  A slash ('/') is used to separate the command and switch. For
  example, the switch-equivalent of the "@nuke" command is
  "@destroy/override".  In some places, the word which is usually the
  command argument can be used as a switch - i.e. "@sweep/connected"
  instead of "@sweep connected".  You do not have to type the full
  name of the switch.

& CONTROL
  CONTROL

  <Object> controls <thing> if:

  1. <Object> is a wizard.

  2. <Object> owns <thing>, and <Object> is a player.

  3. <Object> and <thing> have the same owner, and <thing> is neither
     a player nor INHERIT.

  3. <Object> has the same owner as <thing>, and <object> is INHERIT.

  4. <Object> has the same owner as <thing>, and the owner is INHERIT.

  5. <Object> is in the same zone as <thing>, and <object> passes the
     Enter lock of the zone object. Also, <thing> cannot be INHERIT,
     nor can it be a player.

& ZONE
  Flag: ZONE   (players only)

  The ZONE flag is used to designate a player as a Zone Master. Objects
  owned by a Zone Master are controlled by anyone who passes the player's
  enter lock. This allows zoning based on ownership rather than on the
  zone field, and is more secure, although it does not allow for the
  "local master room" ability of "standard" zones.

  See the topic "ZONE MASTERS" for more information.

& ZONE OBJECTS
  ZONE OBJECTS

  Zones are areas of the MUSH which may be controlled by many people.
  Essentially, they allow group ownership of objects. There are two
  basic types of zones. One is maintained by things and rooms, and
  are the "standard" zones. These are described below. The other type
  is maintained by players. Information on this type of zone is found
  under the topic ZONE MASTERS.

  The default zone is NOTHING. Any building done by a player defaults
  to belonging to the same zone that the player belongs to.
  Every zone is defined by a Zone Master Object (ZMO). The ZMO is an
  ordinary MUSH object owned by some player. A wizard may change the
  zone of an object or player to a ZMO.

  If the ZMO is a room, it is called a "Parent room." Most of the
  statements about ZMOs also apply to parent rooms; for details,
  see the help topic PARENT ROOMS.

  See "help ZONES2" for more.

& ZONES2

  Anyone who can pass the Enter lock of the ZMO has control over all
  objects in that zone. This, in essence, gives that player wizard
  powers within that zone. For this reason, one must be extremely
  careful with the enter locks of ZMOs!

  Also, $commands on a ZMO are treated as global within that zone.
  The game attempts to match $commands for the ZMO of the player's
  location, as well as $commands for the player's own zone.
  For some suggestions on how to use zones, see "help ZONES3".

& ZONES3
  Some suggested uses of zones:

    1. If you are working on a building project with several people, it
       may be useful to create a zone object and @elock it to all of you,
       and ask a wizard to @chzone the players involved to the zone object.
       That way, all of the players working on the project will be able to
       modify the building.

    2. On a similar thread, if several players are working on a project
       involving only a few objects, it may be simpler to create a zone
       object and @chzone those few objects to the ZMO instead of resetting
       the zones of the players. Note that a player does not have to belong
       to a zone in order to change objects in that zone; all is merely
       required to pass the ZMO's enter lock.

    See "help ZONES4" for more.

& ZONES4
  More possible uses for zones:

    3. If local wizards are desired, a zone object may be created and enter
       locked to the local wizard. Players building within that zone should
       be @chzone'd to that ZMO. The local wizard will then be able to
       control anything within that domain.

    4. If you want restricted global commands defined over only a small area,
       you can define that area to be part of a zone, and place the desired
       $commands upon the ZMO.

& PARENT ROOMS

  Parent rooms are a subset of zones. If a room is used as as zone oject,
  it is a parent room (PR). PRs are like local "master" rooms. Exits in
  the PR are global to that zone, and $commands on objects in the PR are
  global to that zone. Parent rooms are only defined if globals are used.
  Parent rooms should only be used for very large zones which have a lot
  of global exits. Otherwise, a ZMO thing should be used, because command
  evaluation on a parent room is slower than command evaluation on a ZMO.
  Large numbers of parent rooms may slow down the game significantly.

  See "help ZONES" and "help EVALUATION" for more information.

& ZONE MASTERS
  ZONE MASTERS

  Zone Masters are player objects which are used to mediate zone control.
  A Zone Master is an object of type PLAYER, which has the ZONE flag set.
  They are created like ordinary players, and can connect, etc.  The only
  difference is that objects owned by Zone Masters are controlled by
  anything that passes the enter lock of the Zone Master.

  Anyone who passes the enter lock of the Zone Master can @chown objects
  to it. This, however, does not refund the original creator's money or
  quota, as does normal @chown. Using a Zone Master instead of a ZMO
  enables a higher degree of security within the zone, and allows INHERIT
  objects to be placed in the zone, since all objects within the zone have
  the same owner. $commands are not, however, inherited off the Zone Master.

  Zone Masters allow a secondary type of zoning, similar but separate from
  the "normal" zone format. The Zone field of the object is not used at all.

& MASTER ROOM
  MASTER ROOM

  The Master Room enables global commands and exits. Exits in the Master
  Room may be used from any location on the MUSH. All objects left in the
  Master Room are checked for user-defined $commands. Those $commands are
  considered global. Normally, only wizards will have access to the Master
  Room. See "help EVALUATION" for details on global commands.

& EVALUATION
  EVALUATION ORDER
  Commands are mated in the following order:
  Special game commands: WHO, QUIT, etc.
  "home" command
  Single-token commands: ", :, ;, +
  Exits in the room
  @-commands
  Regular game commands: get, inventory, etc.
  Enter aliases
  Leave aliases
  User-defined commands on nearby objects. All such $commands are matched
    and executed.
  If there are no user-defined commands nearby:
    If the zone of the player's location is a parent room,
    Parent room exits
    Parent room user-defined commands
    Else
    User-defined commands on the zone of the player's location
  If still nothing is matched:
     User-defined commands on the player's personal zone
  If nothing, including zone commands, has been matched:
     Global exits
     Global user-defined commands: all $commands in the Master Room are
    matched. Local commands are always checked first and ALWAYS negate
    global commands.

& OBJECT PARENTS

  Objects may have "parent" objects, from which they can inherit attributes.
  Once an object is given a parent, it may use the attributes on the parent
  just as if the attributes were on the object itself, including checking for
  $commands. Use the @parent command to change the parent of an object.
  See 'help @parent' for details.

  For the purposes of automated game checks, the following attributes are
  not inherited: CHARGES, EALIAS, LALIAS, LAST, LASTSITE, LISTEN, QUEUE,
  RQUOTA, SEMAPHORE, and STARTUP. These may be "inherited" via the use of
  functions like get(), but the game does not check inheritance for startup
  triggering, enter/leave aliases, runout checking, etc.  Players cannot
  be @parented, but the parent of an object can be set to a player.

  Objects may have multiple levels of parents - thus, if #100 is the
  parent of #101, which is the parent of #102, object #102 checks itself,
  #101, and #100 for attributes. Attributes are checked on the object
  itself first, followed by its parent, followed by that parent's parent,
  and so forth. There is a (configurable) maximum number of ancestors
  an object may have; the default is 10.

  See 'help PARENTS2' for more.

& PARENTS2

  Note that the only properties inherited are attributes. In particular,
  flags and exits are NOT inherited from the parent object. Also, commands
  which walk the attribute list, such as "examine", the LATTR() function,
  @set, and @edit, only affect attributes that are on the object itself.

  There are some limitations to the use of @parent. The most important is
  that ^-pattern checking is not done on the parent of an object, regardless
  of what is on the child object.

  The attributes inherited from the parent are treated just like its
  own attributes by the child. Thus, when a $-command or @trigger is
  executed, "me", for example, refers to the child, not the parent,
  and the $-command's associated actions are performed by the child.
  Also, the uselock check is done on the child, not on the parent.

  Attributes with $-commands _are_ inherited from the parent and
  previous generations. Conflicts are resolved not by the $-command
  name, but by the attribute name.

  See 'help PARENTS3' for more.

& PARENTS3

  If two attributes are in "conflict", the child's attribute is
  used. Thus, if you have @va #10=$test:@emit I'm the child.
  and @va #11=$moof:@emit I'm the parent., and @parent #10=#11,
  and you type "moof", the parent's command will NOT be matched,
  because the child's VA is being used. This is true even if
  the child's VA contains no $-command.

  If instead, you have @va #11=$test:@emit I'm the parent., and
  you type "test", you will get #10 emitting "I'm the child."
  The command does not get double-matched (presuming, of course,
  that the parent doesn't get triggered normally by being in the
  same room with the person who typed "test").

  Since $-command checking only goes one level back, if you had
  a @parent #11=#12, any $-commands on #12 would simply be ignored,
  regardless of what those $-commands were.

  See 'help PARENTS4' for more.

& PARENTS4

  @parent is most useful when several objects use common attributes.
  It is slightly faster to have $commands on the child object which
  in turn @trigger or otherwise retrieve attributes inherited from
  the parent object, rather than having the $commands checked on the
  parent object.

  Parent-object $-command checking is at its most efficient when there
  are few or no attributes on the child. Also, each additional level
  of parents further reduces efficiency.

  If you are "mass-marketing" your objects, you can create blank copies,
  and @parent those copies to a template object. You can then customize
  necessary attributes on the copy. When a buyer @chowns his copy, the
  parent does not change, so unless you're putting data into the parent
  that you want to make impossible to read, it's safe to allow the
  purchasers of your object to @chown their copy.

& LASTSITE
  LASTSITE
  This attribute gives the name of the site you last connected from.
  Mortals cannot set it.

& @alias
  @alias <player>=<alias>

  @alias is a special attribute. When a player sets an @alias, he is
  effectively giving himself a secondary name; he can be paged by his
  @alias, and matched with *<alias>, and all other game functions which
  look up player names will also accept the alias. The attribute is
  visible to all players.

  The normal conventions for player names apply to aliases; they cannot
  contain spaces or certain special characters, cannot be longer than a
  normal player name, and cannot be used by another player.

& @mail
  @mail[/<switches>] [<player>, <msg #>, <command> [= <msg>, <msg #>]]

  @mail invokes the built-in MUSH mailer, which allows players to send
  and receive mail. Pronoun/function substitution is performed on
  any messages you may try to send.

  @mail by itself will give you a brief list of all your mail with the user
        name, time the mail was sent, and will mark all NEW mail with a * in
        front of the message.  All the numbers listed here are the ones used
        when you see <msg #>.

  @mail <player> = <msg>
        This sends the message <msg> to <player>.  All function subsitutes
        are valid in <msg> including mail(#) which will allow you to forward
        mail you have recieved to other users.

  @mail <msg #>
        This displays the message from your mailbox that has the number
        <msg #>...

  Type 'help @mail2' to continue:
& @mail2

  @mail <msg #> = <msg>
        This sends <msg> to the user that sent you the message in your
        mailbox that has the number <msg #>.  (Essentially a 'reply', but
        no special effects, just sends <msg> normally)

  @mail clear
        This clears ALL mail from your mailbox, unread or not.

  @mail clear = <msg #>
        This clears only the message <msg #> and renumbers any messages
        recieved after <msg #>.

  Type 'help @mail3' to continue:
& @mail3

  The @mail command can also take the following switches:

    @mail/stats [<player>]    --  Basic mail statistics.
    @mail/dstats [<player>]   --  Also provides read/unread count.
    @mail/fstats [<player>]   --  Does all that, plus gives space usage.

    @mail/debug <action>[=<player>]

  Only wizards may stats players other than themselves. The mail statistics
  commands are computationally expensive, and thus are subject to "daytime"
  restrictions. They also cost the same as a @find (100 pennies).

  The /debug switch does sanity checking on the mail database, and may only
  be used by a wizard. "@mail/debug sanity" just does the check; the command
  "@mail/debug clear=<player name or dbref number>" wipes mail for an object.

& @config
  @config/[<switch>]

  This command lists the MUSH configuration parameters, indicating what
  special things are enabled, and the cost of certain commands. If
  something doesn't work the way you expected it to, it might be wise to
  use this command and check the configuration paramters.

  This command takes one of three switches:

  /defaults   --   Lists parameters set at compile time or startup time,
                   such as quota restrictions.
  /costs      --   Lists costs for various commands.
  /functions  --   Lists all functions.
  /globals    --   Lists runtime parameters, such as logging and "daytime".

& @map
  @map <list> = <function or pattern>

  This command takes a space-separated list of words, and performs
  pronoun/pattern substitution on each word, returning a list -
  "mapping" the function onto each item in the list. It returns the
  list in a MAPLIST attribute, automatically set on the object executing
  the @map. The set it always performed before any actions further
  actions are executed.

  Brackets are generally necessary in order to make the function
  substitutions evaluate correctly.

  See "help @map-2" for examples of @map.

& @map-2

  Examples of @map:
    @map foobar baz blech=[strlen(##)]
      Returns "6 3 5" in MAPLIST.
    @map testing map-test=[strlen(before(##, est)]
      Returns "1 5" in MAPLIST
    @map Joe Bob Ann=I know ##.
      Returns "I know Joe. I know Bob. I know Ann." in MAPLIST

  >  @va Object=$test * * *:@map %0 %1 %2=[strlen(##)];
           @dolist [v(maplist)] = say ##
  Object - Set.
  >  test aaa bb c
  Object says, "3"
  Object says, "2"
  Object says, "1"

& @dolist
  @dolist <list> = <action>

  @dolist executes the <action> for each element in <list>. If <list> is a
  function, it will be evaluated to obtain the necessary list to use. It
  may be any space-separated list of strings, which can be object numbers,
  attributes, or arbitary words.

  <action> is a command or list of commands enclosed in braces { }
  and is performed once for every item in <list>. The special symbol "##"
  is replaced by the corresponding item from <list>.

  Example: @dolist [lcon(here)] = "[name(##)]
    would cause you to say the name of all objects in the room.

& @fixdb
  @fixdb/<switch> <object>=<value>

  This directly sets a field in <object> to <value>.  <value> must be
  an integer.  Note that NO ERROR CHECKING is performed, so if you mess
  up the setting of <value>, you may very well crash or hang the server
  with your database corruption. This command is restricted to wizards
  only and should NEVER be used unless you know PRECISELY what you are
  doing.

  - Switch -     - Players/things -       - Rooms -        - Exits -
  location       container object         drop-to          destination
  contents       first object carried     first object     nothing
  exits          home                     first exit       source
  next           pointer to next in contents/exits chain

& @readcache
  @readcache

  This wizard-only command reads the text files into the cache. This must
  be done every time the text files (connect text, quit text, etc.) are
  changed while the game is running.

& @kick
  @kick <number>

  This wizard-only command forces the immediate execution of <number>
  items from the queue.
& @ealias
  @ealias <object> = <enter alias>
  This allows a player to type the enter alias instead of "enter <object>"
  If you have a chair, you coud "@ealias chair = sit down" and then just
  type "sit down" instead of "enter chair" - using the object name is
  not necessary. Note that the enter alias is checked after normal exits.
  Like an exit, it may have a semi-colon separated list of words,
  i.e. sit down;sit;sit on chair
& @lalias
  @lalias <object> = <leave alias>
  This allows a player to type the leave alias instead of the "leave"
  command, in a fashion similar to enter aliases (see @ealias for details).
  The leave alias may be a semi-colon separated list of words, such as
  stand up;stand;get up
& @comment
  @comment <object> = <comment>
  This is a wizard-only command which sets a COMMENT attribute on
  <object>. The comment can only be seen by other wizards and royalty.
& @away
  @away <player> = <message>
  This message is sent to a player who tries to page you when you are
  not connected.
& @haven
  @haven <player> = <message>
  This message is sent to a player whose pages you are refusing, either
  through use of the HAVEN flag or through the use of a page lock.
& @idle
  @idle <player> = <message>
  This message is sent in return to every page which successfully reaches
  you. It is useful if you are idle for long periods of time and wish to
  inform people where you are, or if you are in a meeting and cannot
  quickly return pages.
& @ulock
  @ulock <object> = <key>
  This type of lock is a use-lock for objects, and a page-lock for players.
  On an object, this restricts who may trigger the "@use" set of registers,
  and who may use the $commands on the objects. If the person who is trying
  to use the object or its special commands, cannot pass the lock, he is
  told, "Permission denied."  On a player, it restricts who is allowed to
  page that person. If the paging person cannot pass the lock, the target
  player is treated as if he were set HAVEN. Indirect locks and other
  special locking styles are supported; see "help @lock" for details.
  Example: if I want everyone but Bob to be able to page me, I would
  "@ulock me=!*Bob". If I want only Bob to be able to page me, I would
  "@ulock me=*Bob".
& @uunlock
  @uunlock <object> = <key>
  Page-unlocks a player or use-unlocks a thing. Someone who is page-unlocked
  may be paged by anyone; an object which is use-unlocked may be used by
  anyone. See "help @ulock" for more.
& @efail
  @efail <object> = <message>
  This is the message shown to the player who fails to enter the object.
& @oefail
  @oefail <object> = <message>
  This message is shown to the location of a player who fails to enter
  the object.
& @aefail
  @aefail <object> = <action>
  This is the action taken by the object when a player fails to enter it.
& @elock
  @elock <object> = <key>
  Enter-locks an object, restricting who is allowed to enter it. Special
  lock types are supported (see "help @lock" for details). Only objects
  which are ENTER_OK may be entered, regardless of the key.

  The enter lock of a room is its Teleport Lock. Only people who pass
  the room's teleport lock, are wizards or royalty, or control the room,
  will be allowed to @teleport into the room. (Note that this is different
  from NO_TEL, which prevents people from teleporting out of a room).
  The teleport lock is evaluated even if the room is JUMP_OK - in other
  words, if you are trying to teleport into a room you don't control, the
  room must be JUMP_OK, and you must pass the teleport lock.

  Note that the enter lock of an object or room being used as a Zone
  Master Object determines control of that zone. Please note that if
  you're using a room as a ZMO (i.e. as a parent room), only the
  controllers of that zone will be able to teleport into that room
  (which is a good thing for security).

& @eunlock
  @eunlock <object>
  Enter-unlocks an object, in a fashion similar to @unlock. For anyone
  to be able to enter an object, it must be both @eunlocked and ENTER_OK.
& @nuke
  @nuke <object>
  Destroys an object, overriding the SAFE flag. Aside from this
  feature, it is identical to @destroy. This command is equivalent
  to @destroy/override.
& drop
  drop <object>. Drops <object>. Dropping a thing in the temple
  sacrifices it (See SACRIFICING). Otherwise, a dropped thing is
  relocated to the current room, unless its STICKY flag is set
  (See STICKY), or the room  has a drop-to (See DROP-TOs). Unlinked
  exits can only be dropped in rooms you  control.

& examine
  examine[/<switch>] <object>[/<attribute>]

  Displays all available information about <object>.  <object> may be an
  object, 'me' or 'here'. You must control the object to examine it.  If
  you do not own the object, or it is not visible, you will just see the
  name of the object's owner.  May be abbreviated 'ex <object>'.  If the
  attribute parameter is given, you will only see that attribute (good
  for looking at code). You can now wild-card match on attributes.  For
  example. to see all the attributes that began with a 'v' you could do
  ex <object>/v*

  Examine takes two switches, "brief"  (equivalent to the "brief" command),
  and "debug", which is a wizard-only switch.  "debug" examine will show
  the raw values for certain fields in an object.

& brief
  brief <object>. It is identical to "examine", except that it does
  not print the attributes on an object. This is useful for just
  glancing at an object to determine its home, owner, lock, etc.

& get
  get <object>. Picks up <object>. <object> can be a thing or an
  unlinked exit. 'take' is the same as 'get'.
  You can now also do get <thing>'s <object>.  It will fail if
  either thing is not ENTER_OK or object is locked against you.

& give
  give <player>=<pennies/object>. Gives player the specified number of
  pennies or <object>. You can't give someone pennies if their new total
  would be greater than 10000 pennies. (No reason to get greedy)  You
  may also give players objects, but the other player must be set to
  enter_ok (See FLAGS) to receive something you give.

& goto
  go[to] <direction>; go[to] home. Goes in the specified direction.
  'go home' is a special command that returns you to your starting
  location. The word 'go' may be omitted. 'move' is the same as 'go'.

& inventory
  inventory. Lists what you are carrying.
  Can be abbreviated by just 'i', or 'inv'.

& kill
  kill <player> [=<cost>]. Attempts to kill the specified player.
  Killing costs <cost> pennies, which gives you a <cost>% chance of
  killing the player. Thus, spending 100 pennies always works (except
  against wizards,  who can never be killed). Players cannot be
  killed in rooms which have been set HAVEN. (See FLAGS and HAVEN).
  If you don't specify a cost, the default is 10 (i.e. 10%).  The
  player, if killed, receives <cost>/2 pennies in insurance.

& look
  look[/<switch>] [<object>].

  Displays the description of <object>, or the room
  you're in if object is eliminated.  Specifying object as <name> or
  #<dbref> or 'me' or 'here' is legal. 'read' is the same as 'look'.
  You can also use look to look at object's held by other people,
  just use 'look <person>'s <object>'.
  'look' may be abbreviated 'l'.

  Look does take one switch, "outside". look/outside allows you to
  look at objects outside your current location, as long as your
  immediate location is not a room, and is not OPAQUE.

& move
  Same as GO.  (What, you expect me to type it out twice?)
& news
  Shows you the current news for MUSH. It is highly recommended that
  you check the news daily for new information.  Otherwise, the
  wizards will have no pity on you for messing up with the new
  commands.
& events
  A file similar to news, dealing with special events and topics with
  the MUSH. You should check the events daily for new information,
  or you may rapidly become slightly lost.
& page
  page [<player>] [=<message>]. This tells a player that you are
  looking for them, and tell the player where you are.  They will get
  a message telling them your name and and location if you omit the
  message. This costs 1 penny.  If you include the '=<message>', it
  will tell the player your name and your message, but not your
  location.  If a player is set to HAVEN (See FLAGS), you
  cannot page them, and they will not be notified that you tried.
  If the player is page-locked against you, he is treated as HAVEN.
  Page will also attempt to partial match on the name.  If you omit the
  player, the game will attempt to page the player you paged last.
  If the first character of <message> is a : or a ;, it will send the
  page in pose format.  (see pose, : and ;)
  Objects may page players, but not vice versa. If an object pages
  a NOSPOOF player, that player will see the object's number in
  square brackets, in front of the message, in a fashion similar to
  the way NOSPOOF flags emits.
& QUIT
  QUIT. Log out and leave the game. Must be in all capitals.
& LOGOUT
  LOGOUT is similar to QUIT, but instead of disconnecting you from the
  game completely, it merely disconnects you from your current character
  and returns you to the opening welcome screen. This is useful if you
  want to disconnect and then reconnect to another character.
& read
  See 'look'.  (See move for reason you have to see look)
& "
  See say.
& :
  See pose.
& ;
  This command is much like pose, however where with pose, the action
  and the person's name who commits the action are separated by a
  space, with ;, they are not.  Example: ;'s watch beeps. -- The room
  would see <name>'s watch beeps.
& +
  See @chat.
& &
  See NON-STANDARD ATTRIBUTES.
& say
  say <message>. Says <message> out loud. You can also use
  '"<message>'.  See also 'whisper', 'pose', and ';'.
  (Note: Say and " append a " to whatever you type in)
& score
  score. Displays how many pennies you are carrying.  Helpful to see if
  any machines are looping.  Also see looping, @ps, and most of the
  commands that start with @.
& slay
  slay <player/object> This is a Wizard command that kills players
  without paying any insurance to the victims. It is used in places
  where 'suicide' should not pay.
  (Su-ic-ide is pain-less... {MASH theme})
& take
  See 'get'.
& whisper
  whisper <player>=<message>. Whispers the message to the
  named person, if they are in the same room as you. No one else can
  see the message. You can also whisper to things you are carrying,
  or to things that are carrying you. whisper <player>=:<pose> also
  works, in a fashion similar to page-pose.
  'whisper' can be abbreviated by just 'w'.
& WHO
  WHO   Displays a list of players currently connected to the MUSH.
  The WHO tells you how long a player has been on and how long they
  have been inactive.
& DOING
  This command displays the list of players currently connected to the
  MUSH. For mortals, it is identical to WHO. For wizards, it displays
  the WHO in the format mortals see. The wizard WHO shows location and
  host, but does not show @doing messages. DOING shows @doing messages
  but not location or host.
& @poll
  @poll <poll question>
  This wizard-only command sets the "poll" - the Doing question. If
  "@poll" is used by itself, the question is reset to the default
  string "Doing".
& @aahear
  An Aahear on an object is activated whenever the listen pattern
  matches anything done/said by anything else in the room, and
  itself.  (Ahear ignores itself, helpful from keeping machines from
  triggering itself)  See @listen, @ahear, @amhear.
& @aclone
  The @aclone of an object is the action to be executed when that
  object is @cloned. It works just like other @a<whatever> attributes.
  Please note that there is no @oclone, and that @clone is always a
  command, not an attribute.
& @adescribe
  @adescribe <object> = <actions>.

  Sets the actions to be taken when  <object> is looked at. Actions are
  lists of commands separated by semi-colons and these commands are
  executed by the object (see also PUPPET). Things can execute almost any
  command but rooms and exits are restricted to forcing objects/puppets to
  do things. Function/percent substitutions are applied to the commands b
  efore they are executed. <object> can be specified as <name> or #<number>,
  or as 'me' or 'here'.  May be abbreviated @adesc. See also @describe,
  @idescribe and @odescribe.

  Some people find @adescs on people to be annoying. Be aware of this
  before you set one.
& @afailure
  @afailure <object> = <actions>. Sets the actions to be taken on
  failure to use <object>. Actions are lists of commands separated by
  semi-colons and these commands are executed by the object (see
  puppet).  Things can execute almost any command but rooms and exits
  are restricted to forcing objects/puppets to do things. Gender
  substitutions are applied to the commands before they are executed,
  this allows use of the players name who caused the action.
  <object> can be specified as <name> or #<dbref>, or as 'me' or
  'here'. May be abbreviated @afail. See also @fail and @ofail.
& @ahear
  @ahear <object> = <actions>. Sets the actions to be taken after a
  string set in the @listen (See @listen) is matched. Actions are
  lists of commands separated by semi-colons and these commands are
  executed by the object (see puppet). Objects can execute almost
  any command. Gender substitutions are applied to the commands
  before they are executed, this allows use of the players name who
  caused the action.
  See also @aahear and @amhear.
& @adeath
  @adeath <object> = <actions>. Sets the actions to be taken after
  <object> is killed. Actions are lists of commands separated by semi
  colons and these commands are executed by the object (see puppet)
  Objects can execute almost any command. Gender substitutions are
  applied to the commands before they are executed, this allows use
  of the players name who caused the action.
  See also @odeath and @death.
& @amhear
  @amhear is like @ahear, only the @listen string/pattern is only
  applied to statements/strings that the object itself generates.
  @amhear and @ahear together equal @aahear.  See @ahear, @listen,
  and @aahear.
& @apayment
  @apayment <object> = <actions>. Sets the actions to be taken after a
  player gives object pennies (see @cost). Actions are lists of
  commands separated by semi-colons and these commands are executed
  by the object (see puppet). Objects can execute almost any command.
  Gender substitutions are applied to the commands before they are
  executed, which allows use of the player's name who caused the
  action. May be abbreviated @apay. See also @pay and @opay.
& @ause
  @ause <object> = <actions>. Sets the actions to be taken when an
  object is succesfully "used". Actions are lists of commands separated
  by semi-colons. This functions in a similar manner to the other
  @a-attributes, such as @asuccess and @apayment.
& @asuccess
  @asuccess <object> = <actions>. Sets the actions to be taken on
  successful usage of <object>. Actions are lists of commands
  separated by semi-colons and these commands are executed by the
  object (see puppet). Objects can execute almost any command. Gender
  substitutions are applied to the commands before they are executed,
  this allows use of the players name who caused the action. It can
  be abbreviated @asucc. <object> can be specified as <name> or
  #<dbref>, or as 'me' or 'here'. See also @success and @osuccess.

& @adrop <object> = <actions>. Sets the actions to be taken when
  <object> is dropped. See "help @asuccess" for a more detailed
  explanation of action attributes.

& use
  use <object>
  Attempts to use an object, triggering its @use/@ouse/@ause attributes.
  The person using the object must pass its uselock; no inheritance check
  is necessary. This is may be done remotely, by using a dbref number;
  it provides an easy way for non-INHERIT objects to perform commands on
  INHERIT objects.

& @boot
  @boot <player>    or   @boot/port <descriptor number>

  Disconnects the player from the game. The /port switch takes a
  descriptor number instead (the "Port" number in WHO for wizards).
  Only Wizards can use this command, so you better not be naughty! Heh!

  (Well, you can be naughty... it's annoying that gets on the nerves
   of wizards real quickly. Ex: @adesc me = kill %N = 100 will get you
   @booted real quickly.)

& @charges
  @charges <object> = <integer>. Allows you to limit the # of times
  an action can be used. If there is a charges attribute it is
  decremented each time an action is triggered, once it reaches zero
  actions are disabled. See also @runout.

& @chown
  @chown <object>=<player>. Changes the ownership of <object> to
  <player>.  Objects may be things, rooms or exits. To chown things,
  you have to be carrying the thing. For rooms or exits, you have to
  be in the room. Objects must have the chown_ok flag set before it
  can be @chowned (See FLAGS).  In a room, the command used must be
  @chown here = <name>, and for an object, you must be very specific.
  Note:  @chown DOES understand the pronoun me.
  Players can't be @chowned; they always own themselves.

& @chzone
  @chzone <object>=<zone object>. Changes the zone of <object> to
  <zone object>. If <zone object> is "none", the zone is reset to
  NOTHING. @chzone'ing a player does not automatically change the
  zone of his objects.
  Anyone may reset the zone of an object he owns; the zone he changes
  the object zone must either be "none", or must be owned by him.
  Only wizards may @chzone an object to an arbitrary zone object.
  Players may @chzone themselves to an object they own; otherwise,
  only wizards may @chzone players. @chzone'ing resets the WIZARD,
  ROYALTY, and INHERIT flags on non-player objects. See "help ZONES"
  for an explanation of zones.
& @chzoneall
  @chzoneall <player>=<zone object>. Changes the zone of all objects
  owned by <player> to <zone object>. If <zone object> is "none",
  the zone is reset to NOTHING. Only wizards may use this command.
& @clone
  @clone <object or exit>
  For objects, creates an exact duplicate of it and puts it in the
  current room. For exits, it creates an exact duplicate of that
  exit, except the clone's source is the current room rather than
  whatever the original exit's source was.
& @cost
  @cost <object> = <amount> number of pennies that need to be given to
  an object to trigger @pay, @opay and @apay. Example:
  @cost exit-machine=10
  @apay exit-machine=@open %N-exit
  @pay exit-machine=Your exit has been created.
& @create
  @create <name> [=<cost>]. Creates a thing with the specified name.
  Creation costs either <cost> pennies or 10 pennies, whichever is
  greater. The value of a thing is proportional to its cost. To be
  exact, value=(cost/5)-1.  Value cannot be greater than 100, any
  values that would be greater than 100 are rounded down to 100.
  (see give re: greed)
& @describe
  @describe <object> [=<description>]. <object> can be a thing,
  player, exit, or room, specified as <name> or #<number> or 'me' or
  'here'.  This sets the description a player sees when they use the
  command 'look <object>'. Without a description argument, it clears
  the message. It can be abbreviated @desc.  @desc's on everything
  that isn't dark is considered to be Good Building Practice.
& @destroy
  @destroy[/override] <object>

  Recycles <object> and returns the player's investment (the cost of @create)
  You should always @destroy objects you no longer need; this keeps the
  database down to a manageable size.

  @destroy may be used to recycle any object but will have a delayed
  effect on rooms.  Rooms are removed approximately every ten minutes,
  until then, they have the Going (G) flag set on them.  Should you
  change your mind, simply@set <room> = !Going.

  The queue for destroyed objects is automatically cleared. In addition,
  the equivalent of a @drain is performed: all commands waiting on it
  as a semaphore are immediately discarded(not run at all).
  You should always @destroy objects that you no longer need. This
  keeps the database down to a manageable size.

  The SAFE flag protects objects from destruction. The /override
  switch negates this protection (and is equivalent to "@nuke").
  The DESTROY_OK flag allows anyone who is holding an object to
  @destroy it. This is good for "temporary" objects like "Can of Cola".
& @dig
  @dig[/teleport] <name> [= <name>[;<other name>]*[,<name>[;<other name>]*]]

  Creates a new room with the specified name and displays its number.
  This costs 10 pennies. If the [= <name>....*] option is used, the
  exit will be opened and linked for you.  The [,<exit>...*] option
  will link a reverse exit for you.
  If the "teleport" switch is supplied, the digger will be teleported
  into the new room automatically.

  Example: @dig Kitchen = Kitchen;k;north;n will dig a room called
    Kitchen, and open an exit called 'Kitchen' in your current room.
  Example 2: @dig Kitchen = Kitchen;k;north;n,out;o;south;s will dig
    a room called Kitchen, open an exit called 'Kitchen' in the current
    room, AND open an exit 'out' in the room 'Kitchen' leading to the
    current room.
  The ; symbol means that you may enter the exit by typing
  'k','north' or 'n' also.  Only the first Exit name is displayed in
  the Obvious exits list.
& @drop
  @drop <object> [=<message>]. <object> can be a thing, player, exit,
  or room, specified as <name> or #<number> or 'me' or 'here'. Sets
  the drop message for <object>. The message is displayed when a
  player drops <object>. Without  a message argument, it clears the
  message.
  See also @odrop and @adrop.
& @gedit
  @edit now takes wildcard patterns, so this command is merely an alias
  for @edit, kept for backwards compatbility. See "@edit" for details.
& @edit
  @edit <object>/<pattern> = <search>,<replace>
  @edit <object>/<pattern> = $,<string to append>
  @edit <object>/<pattern> = ^,<string to prepend>

  This is useful when you don't want to have to retype those obnoxiously
  long descriptions just to make one little change.  Instead, search and
  replace via @edit.

  <pattern> is a pattern, optionally containing wildcards, for the attribute
  names you wish to edit. Only attributes already defined on <object> may be
  edited. <search> and <replace> are two strings. It's also possible to use
  "$" and "^" to signal appending and prepending text, respectively.

  If the text contains commas, precent signs, or similar special characters,
  it usually must be enclosed in curly braces.

  See also ATTRIBUTES.
& @grep
  @grep[/<switch>] <object>[/<attrs>]=<pattern>

  This command searches attributes in an object for <pattern>.
  It can taken one of two switches, "list" and "print".  The default
  is "list", and simply lists the attributes in the object which contain
  the pattern.  The "print" switch prints out all the attributes which
  contain the pattern, hiliting the pattern itself in boldface  (you must
  be ANSI_DISPLAY in order to use this switch).

  You must be able to see attributes on <object> (i.e. you must control
  the object, it must be VISUAL, or you must be a Wizard or Royalty).

  <attrs> is an optional wildcard pattern specifying attributes to
  match (much like @edit). If <attrs> is not provided, all attributes
  are assumed (just as if you had provided "*").

  <pattern> is not treated as a wildcard pattern, so you can grep for
  patterns containing '*', '?', etc.  Also, <pattern> is NOT PARSED,
  so '[v(0)]' and the like can be searched for.
& @emit
  @emit [/room] <message>  This send message to every person in the
  current room. However, no identifier marking it as being sent by you
  is shown.  For example, @emit foo would show 'foo' to every object in
  the room. The /room switch makes this command equivalent to "@lemit".
  See also @pemit, @remit, @oemit, @lemit, NOSPOOF and SPOOFING.
& @failure
  @failure <object> [=<message>]. <object> can be a thing, player, exit,
  or room, specified as <name> or #<number> or 'me' or 'here'. Sets
  the fail message for <object>. The message is displayed when a
  player fails to use <object>.  Without a message argument, it
  clears the message. May be abbreviated @fail. See also @afail and
  @ofail. Putting @fails on all exits and objects that are locked is
  Good Building Practice.
& @find
  @find [<name>] [=<begin>,<end>]

  Displays the name and number of every room, thing, or
  player that you control whose name matches <name>. Because the
  command is computationally expensive, this costs 100 pennies.
  You can limit the range of the @find by specifying <begin> and
  <end>, where these are the first and last dbrefs to examine.

& @force
  @force <player/object>=<command>. Forces the game to act as though
  <player/object> had entered <command>.  Only wizards may force
  players. May be abbreviated @fo.  Wizards cannot be forced by
  players. Hard luck. You can always force objects you control, and
  will probably use this command to manipulate puppets.
  An abbreviated form of this command is simply "<#dbref> <command>".

& @death
  @death <player> [=<message>]. <player> can be specified as <name> or
  #<dbref> or 'me' or 'here'. Sets the death message for <player>. The
  message is displayed when <player> is killed. Without  a message
  argument, it clears the message.  See also @adeath and @odeath.
& @idescribe
  @idescribe <object> [=<message>].  Sets object's internal description.
  The internal description of an object will be shown to any object
  entering it.  Without a message argument, it shows the usual @desc.
  (see enter, @enter, @oenter, and enter_ok).  May be abbreviated @idesc
& @link
  @link <object>=<number>; @link <object>=here;
  @link <dir>|<room>=home. Links <object> to room specified by
  <number>. For things and players, sets the home room (See HOMES).
  For rooms, sets the drop-to room (See DROP-TOs). For exits, sets
  the target room; exits must be unlinked, and you must own/control
  the target room unless its LINK_OK flag is set. Linking an exit
  costs 1 penny. If the exit was owned by someone else, the former
  owner is reimbursed 1 penny. (see @open, @dig)

  LINK_OK objects can also be used as semaphores, and any object
  can be @parented to them.
& @listen
  @listen <object> = <string>. A wildcard pattern for an object to
  listen for.  If/when <string> is heard, the object's ahear is
  triggered. Note: if @listen is matched the objects contents will
  also hear the message. See "help LISTEN" for more details.
& @lock
  @lock[/<switch>] <object>=<key>

  Locks <object> to a specific key(s). <object> can be specified as
  <name> or #<number>, or as 'me' or 'here'.
  Boolean expressions are allowed, using '&' (and), '|' (or),
  '!' (not), and parentheses ('(' and ')') for grouping. To lock to a
  player, prefix their name with '*' (ex. '*Moonchilde').

  The available switches on this command are /enter, /tport, /use, and
  /page. The first two are equivalent to @elock, and the latter two to
  @ulock.

  Example:
   @lock Purse = me|*Darling will lock object purse so that only you
   or player Darling can take it.

  See "help @lock2" for more.

& @lock2
  There are six types of special locks: Indirect, Carry, Is, Owner,
  Attribute, and Evaluation locks.

  Indirect locks -- locks an object to the lock of the specified
  object.  Good if you have many locks with the same key, simply
  lock all the locks to one object, then lock that object to the
  common key.
  Example:
    @lock foo=@bar    locks foo to bar's key.

  Carry lock -- You can go though only if you carry foo.
  Example:
    @lock bar = +foo

  Is lock -- You can only go through if you ARE foo.
  Example:
    @lock bar = =foo
  The last two are different from @lock foo = bar in that
  @lock foo=bar will let you pass either if you carry bar or are bar.

  See "help @lock3" for more.

& @lock3

  Owner lock -- You can only go through if you have the same owner as foo.
  Example:
    @lock bar = $foo

  Attribute lock -- You can only go through if you have an attribute
  set on yourself which matches the value of the attribute lock.
  The value is a string which may contain wildcards, greater than,
  and less than.
  The locked object must be able to read the attribute from the thing
  trying to pass the lock; if it cannot do so, the thing cannot pass
  the lock. (So, mortals can generally only usefully lock to public
  attributes like 'sex', or to attributes on their own objects).
  All attribute locks take the format @lock thing=attribuate:value
  Example:
    @lock thing=sex:m*      will lock thing to anyone whose sex attribute
                            starts with an 'm'.
    @lock exit=name:<g      will lock the exit against any one whose name
                            is higher than f.

  See "help @lock4" for more.

& @lock4
  Evaluation locks -- These locks take the form @lock thing=attribute/value
  They are thus very similar in form to attribute locks. These locks are
  checked by evaluating the contents of <attribute> and comparing it to
  <value>; a lock is passed if these are equal.

  <Attribute> may be thought of much like a user-defined function; its
  contents are evaluated with the equivalent of EVAL(thing, attribute)
  For the purposes of evaluation, the player trying to pass the lock
  on thing is the enactor (%N) and the thing is "me" (%!)

  Example: @lock thing = Ispuppet/1
           &Ispuppet thing = [hasflag(%#, PUPPET)]

  This locks thing to puppets only. If player tries to pass the lock on
  thing, Ispuppet evaluates to: [hasflag(<player dbref>, PUPPET)]
  and the function returns 0 or 1 depending on whether or not player
  is a puppet. The lock is passed if the evaluation equals "1".

  See "help @lock5" for more.

& @lock5
  Evaluation locks are extremely flexible; you can even use them to
  imitate other types of locks. For example, instead of @lock object = #5
  you can use @lock object = VA/#5   and   @va object = %#
  (This is somewhat foolish, but you can do it if you want to.)

  These locks are evaluated with the priviledges of the locked object;
  thus, if you  @lock object = VA/5   and  @va object = [strlen(get(%#/VZ))]
  and the object does not have permission to read VZ from the player
  trying to pass the lock, the player automatically fails to pass the
  lock.
& @name
  @name <object>=<new name> [<password>]. Changes the name of
  <object>.  <object> can be a thing, player, exit, or room,
  specified as <name> or #<dbref> or 'me' or 'here'. For a player,
  it requires the player's password.
& @newpassword
  @newpassword <player> =<password>. Only wizards may use this
  command.  Changes <player>'s password, informing <player> that you
  changed it.  Must be typed in full. If you forget your password,
  log on as guest (password = guest) and talk to a Wizard.
& @odescribe
  @odescribe <object> [=<message>]. The odescribe message, prefixed
  by the player's name, is shown to others when the player looks at
  <object>. Without a message argument, it clears the message.
  <object> can be specified as <name> or  #<number>, or as 'me' or
  'here'. May be abbreviated @odesc. See also @describe, @adescribe
  and @idescribe.
& @odrop
  @odrop <object> [=<message>]. The @odrop message, prefixed by the
  player's name, is shown to others when the player drops <object>.
  Without a message argument, it clears the message. <object> can be
  specified as <name> or #<number>, or as 'me' or 'here'. See also
  @drop and @adrop.
& @ofailure
  @ofailure <object> [=<message>]. The @ofail message, prefixed by the
  player's name, is shown to others when the player fails to use
  <object>. Without a message argument, it clears the message.
  <object> can be specified as <name> or #<dbref>, or as 'me' or
  'here'.  May be abbreviated @ofail.
  See also @afail and @fail.  (Note: @ofails on locked exits and
  objects is considered Good Building Practice.)
& @odeath
  @odeath <player> [=<message>]. The @odeath message, prefixed by the
  player's name, is shown to others when the player is killed.
  Without a message argument, it clears the message. <player> can be
  specified as <name> or #<dbref>, or as 'me' or 'here'. See also
  @adeath and @death.
& @opayment
  @opayment <object> [=<message>]. The opay message, prefixed by the
  object's name, is shown to others in the room with object when someone
  'pays' for something. Without a message argument, it clears the message.
  <player> can be specified as <name> or  #<dbref>, or as 'me' or 'here'.
  May be abbreviated @opay. See also @apay, @pay, and @cost.
& @open
  @open <direction>[;<other direction>]* [=<number>][,<dir>[;<other dir]*].
  Creates an exit in the specified direction(s). If <number> is specified,
  it is linked to that room. Otherwise, it is created unlinked. You or
  anyone else may use the '@link' command to specify where the unlinked
  exit leads.  Opening an exit costs 1 penny. If you specify <number>,
  linking costs 1 more penny.  If you specify a room, you may also specify
  an exit leading from that room back to the current room.  This second back
  exit costs the same as the forward one.  See also @link and @dig.
& @osuccess
  @osuccess <object> [=<message>]. The @osuccess message, prefixed by
  the player's name, is shown to others when the player successfully
  uses <object>.  Without a message argument, it clears the @osuccess
  message. It can be abbreviated @osucc. <object> can be specified as
  <name> or #<number>, or as 'me' or 'here'. See also @success and
  @asuccess. (Putting @osuccs on all useable exits and takeable
  objects is considered Good Building Practice, especially if it
  allows people to follow people w/o shouting out which exit to take
  each time you leave a room.)
& @ouse
  @ouse <object> [=<message>]. The @use message, prefixed by the player's
  name, is shown to others when a player successfully does a "use" on
  the object. Without a message argument, it clears the @ouse message.
  See also @use and @ause.
& @tport
  @tport <object> [=<message>]

  Sets the <message> shown to <object> when <object> is teleported.
& @otport
  @otport <object> [=<message>]

  Sets the <message>, which will be prefixed by <object>'s name,
  that will be shown to the others in the room that the <object>
  is teleported to.
& @atport
  @atport <object> [=<action list>]

  Sets the list of actions that <object> will perform when it is
  teleported. These actions are done after <object> has arrived
  in its new location.
& @oxtport
  @oxtport <object> [=<message>]

  Sets the <message>, which will be prefixed by <object>'s name,
  that will be shown to those in the room that the object has
  left via @teleport.
& @password
  @password <old password>=<new password>. This changes your
  password.  It can be abbreviated @pass.
& @payment
  @payment <object> [=<message>]. The pay message is shown to the player
  who paid the object. Without a message argument, it clears the message.
  <player> can be specified as <name> or  #<number>, or as 'me' or 'here'.
  May be abbreviated @pay. See also @apay, @opay, and @cost.
& @pemit
  @pemit[/<switch>] <object> = <message>

  The basic form of this command sends <message> to <object> directly.
  It is very similar in its effects to @emit except only one object
  will see the message. You may @pemit to objects in the same room,
  objects you are carrying, and to objects that are carrying you,
  or @pemit remotely, using #<object> or *<player name>.

  The @pemit command can also take the following switches:
    /contents  -- equivalent to @remit.
    /silent    -- does not tell the @pemit'ing object a confirmation message.

  See also @emit, @oemit, @remit, NOSPOOF, and SPOOFING.
& pose
  pose <action pose>. Displays your name followed by the statement
  you posed.  May be abbreviated by the ':' symbol. Example:
  If you are player Bob, and you type in ':laughs out loud'
  everybody in the room will see: "Bob laughs out loud"
  The "pose" command is obsolete and has been completely replaced by ':'
& @runout
  @runout <object> = <actions> This is an action to be taken when
  charges reach zero (See '@charges'). Actions are lists of commands
  separated by semi-colons, and these commands are executed by the
  object (see puppet). Things can execute almost any command but
  rooms and exits are restricted to forcing puppets to do things.
  Gender substitutions are applied to the commands before they are
  executed, this allows use of the players name who caused the
  action.
& @search
  @search [<player>] [<class>=<restriction>] [,<begin>,<end>]

  This command searches the database and lists objects which meet user
  specified search criteria.  You can limit the scope of the search by
  specifying <begin> and <end> as the first and last dbrefs to search.

  If a <player> argument is supplied, only objects owned by that player
  will be listed. If a <class> argument is supplied only objects of a
  certain class will  be listed. Possible <class>es include TYPE, NAME,
  ZONE, PARENT, EXITS, OBJECTS, ROOMS, PLAYERS, FLAGS, POWERS, and EVAL.
  If <class>=TYPE, possible <restriction>s include OBJECTS, ROOMS,
  EXITS, PLAYERS.

  If <class>=NAME, only objects whose name begin with the string <restriction>
  will be listed. If <class>=ZONE, only objects in the zone <restriction>
  will be listed. If <class>=PARENT, only children of parent <restriction>
  will be listed. For ZONE and PARENT, <restriction> must be specified as a
  dbref number.

  'help @search2' for more.
& @search2
  If <class>=EXITS, OBJECTS, ROOMS, or PLAYERS, only objects of that type
  and whose  name begin with the string <restriction> will be listed.

  If <class>=FLAGS, only  objects with the list of flags specified by
  <restriction> will be listed. Flag names should be specified by single
  letters. Flag names are case-sensitive.

  If <class>=POWERS, only objects with the given power are listed. Only
  one power may be specified.

  If <class>=EVAL, only objects for which <restriction> evaluates to 1
  will be listed. The token '##' in <restriction>, which is a function,
  is replaced by each dbref sequentially.

  See "help @search3" for more.

& @search3
  For the class TYPE=PLAYER, and for  PLAYER=<player-name>, anyone may
  obtain information on any player.  In all other cases, only wizards may
  obtain information about other players. This is computationally
  expensive, costing 100 pennies. It is generally faster than @find.

  Examples:
    @search flags=Wc      <-- search for connected wizards.
    @search type=rooms    <-- list all rooms owned by me.
    @search zone=#50      <-- list all objects belong to zone #50.
    @search Joe,100,200   <-- list all objects from #100-#200 owned by Joe.

    @search eval=gt(money(##,10)     <-- list all objects owned by me
                                         worth more than 10 coins.

& @set
  @set <object>=[!]<flag>
  @<pre-defined attribute> <object>=<value>
  @set <object>=<attribute>:<value>
  @set <object>=<new>:_<thing>/<old>
  @set <object>/<attribute>=[!]<atrflag>

  The first form sets (or unsets) a flag on <object>.
  The second form sets a pre-defined attribute (such as MOVE, FAIL, etc.)
  on <object>.
  The third form sets an arbitrary attribute with <value> on <object>.

  The fourth form is used for copying attributes. It sets an attribute
  <new> on <object> with the contents of <thing>'s <old> attribute.
  (For example: @set me=TEST1:_fluff/fail  would copy the contents of
  the object "fluff"'s FAIL attribute into an attribute called TEST1 on me)

  See "help @set2" for more.

& @set2
  The fifth form sets (or unsets) an attribute flag on the specified
  attribute. Possible flags are:

  no_command        Attribute will not be checked for '$' commands and
                    '^' listen patterns. In an 'examine', this is denoted
                    by '$' next to the dbref of the attribute's owner.
  visual            Attribute can be seen by anyone via get(), eval(),
                    ufun(), zfun(), and similar functions. In 'examine',
                    this is denoted by 'v'.
  no_inherit        Attribute will not be inherited by the children of
                    this object. In 'examine', this is denoed by 'i'.
  no_clone          Attribute will not be copied if the object is @clone'd.
                    In 'examine', this is denoted by 'c'.
  mortal_dark       Attribute cannot be seen by mortals. Denoted by 'm'.
                    This flag can only be set by royalty and wizards.
  wizard            Attribute can only be set by wizards. Denoted by 'w'.
                    This flag can only be set by royalty and wizards.

  See also FLAGS, NON-STANDARD ATTRIBUTES.
& @sex
  @sex <player> = <gender>  Used for pronoun substitution, normally
  male or female. Visible to all. Examples:
  @sex me = Male
  @sex me = No thank you (silly, but possible)
& @shutdown
  @shutdown. Only wizards may use this command. Shuts down the game.
  Must be typed in full.
& @startup
  @startup <object> = <action list>. This is an action list that gets
  triggered the first time the mud comes up.  If the mud crashes,
  this list will be triggered when the mud comes back up.  Thus, you
  can retrigger objects that need to be running continuously.
  Setting or resetting this attribute automatically sets or
  resets the STARTUP (z) flag.
& @stats
  @stats. Display the number of objects in the game broken down by
  object types.  Wizards can supply a player name to count only
  objects owned by that player.
& @success
  @success <object> [=<message>]. Sets the success message for
  <object>. The message is displayed when a player successfully uses
  <object>. Without a message argument, it clears the message. It
  can be abbreviated @succ. <object> can be specified as <name> or
  #<dbref>, or as 'me' or 'here'. See also @osuccess and @asuccess.
& @use
  @use <object> [=<message>]. Sets the use message for <object>. The
  message is displayed when a player successfully does a "use" on the
  object. Without a message argument, it clears the message.
& @teleport
  @teleport [<object>=] <room>. Teleports <object> to <room>.

  <object> must be a thing; if you do not supply a thing, the object
  is assumed to be yourself. The destination must be either JUMP_OK
  or controlled by you, and you must either control <object> or
  <object>'s current location. Also, the destination, if a room,
  cannot be teleport-locked against <object>. Mortals cannot teleport
  Royalty or Wizards. If the target room has a drop-to, <object> will go
  to the drop-to room instead. Wizards can teleport things into players'
  inventories.

  Teleportation from a room can be stopped by setting the NO_TEL flag.
  Royalty and Wizards can _always_ teleport to any location, regardless
  of NO_TEL or teleport locks.

  Teleportation triggers the @oxtport/@tport/@otport/@atport attributes,
  unless <room> is an exit.

  See also: JUMP_OK, NO_TEL, @oxtport, @tport, @otport, @atport, @elock
& @unlink
  @unlink <dir>; @unlink here. Removes the link on the exit in the
  specified direction, or removes the drop-to on the room. Unlinked
  exits may be picked up and dropped elsewhere. Be careful, anyone
  can relink an unlinked exit, becoming its new owner (but you will
  be reimbursed your 1 penny). See @link.
& @unlock
  @unlock [/<switch>] <object>. Removes the lock on <object>. See @lock.
  It can take four switches: /enter, /tport, /use, and /page.
  The first two are equivalent to @eunlock, and the latter two are
  equivalent to @uunlock.
& @wall
  @wall [/<switch>] <message>. Only wizards may use this command.
  In its default form, this command allows the player to shout
  a message to every player connected. It must be typed in full.
  It can also take the following switches:
  /wizard  : broadcast to wizards (like @wizwall)
  /royalty : broadcast to wizards and royalty (like @rwall)
  /pose    : pose a message to all (like @wallpose)
  /emit    : emit a message to all (like @wallemit)
& @rwall
  @rwall <message>
  Only wizards and royalty may use this command. It broadcasts a message to
  all connected wizards and royals, prefixed with "Admin:". If the first
  character is : or ; it does the same thing as @wizpose.
& @rwallpose
  @rwallpose <pose>
  Only wizards and royalty may use this command. It's a variant of @rwall,
  using a pose, and is identical to "@rwall :<pose>"
& @rwallemit
  @rwallemit <message>
  Only wizards and royalty may use this command. It is similar to @wizemit,
  but broadcasts the message to all connected wizards and royals.
& @wizwall
  @wizwall <message>.  Only wizards may use this command.
  Shouts <message> to all wizards logged in.  If the first character is
  a : or ; it does the same thing as @wizpose. (; doesn't attach the space)
& @wizpose
  @wizpose <message>.  Only wizards may use this command.
  Shows the <message> to all wizards logged on in pose format.
& @wizemit
  @wizemit <message>.  Only wizards may use this command.
  Shows <message> to all wizards logged on in emit format.
& @whereis
  @whereis <player>. Tells you the location of the player. If you
  wish to remain unlocatable, set your UNFINDABLE flag. (See FLAGS).
  The person being located will get a message to inform them that you
  have successfully or unsuccessfully located them.
  Ex: @whereis  Moonchilde
& ATTRIBUTES
  ATTRIBUTES

  The following standard attributes can be set on your character.
  These attributes are set by typing @<attribute> <object> = <value>.
  Typing help on the @-command associated with each attribute will get
  you help on that attribute.  Attributes with (*) after them are special,
  and a) cannot be set by players and b) are possibly only visible to
  wizards. There is a section also on NON-STANDARD ATTRIBUTES.

  AAHEAR        ACLONE        ACONNECT      ADEATH        ADESCRIBE
  ADISCONNECT   ADROP         AEFAIL        AENTER        AFAILURE
  AHEAR         ALEAVE        AMHEAR        AMOVE         APAYMENT
  ASUCCESS      AWAY          CHARGES       COST          DEATH
  DESCRIBE      DOES          DROP          EALIAS        EFAIL
  ENTER         FAILURE       HAVEN         IDESCRIBE     IDLE
  LALIAS        LAST (*)      LASTSITE (*)  LEAVE         LISTEN
  MOVE          ODEATH        ODESCRIBE     ODROP         OEFAIL
  OENTER        OFAILURE      OLEAVE        OMOVE         OPAYMENT
  OSUCCESS      OXENTER       OXLEAVE       PAYMENT       PASSWORD (*)
  QUEUE (*)     RQUOTA (*)    RUNOUT        SEX           STARTUP
  SUCCESS

  Those with a (*) above have a separate help section for each of them
  so that you can find out what each attribute controls.
  Any attribute name can be shortened, but at shorter forms run the risk
  of conflicting with other attribute names.  This could result in you
  setting an unwanted attribute.
& LAST
  LAST

  This attribute shows the last time you connected to the MUSH. It is
  only visible to objects that control you (wizards, you or your objects)
  or if you set yourself VISUAL.
& PASSWORD
  PASSWORD

  This attribute stores your encrypted password.  It is not visible to
  anyone within the game, and cannot be altered except via the @password
  and @newpassword commands.
& QUEUE
  QUEUE

  This attribute is only visible to objects that control you (wizards,
  yourself, and your objects) or unless you are VISUAL.  It tracks how
  many active commands you have in the queue.
& RQUOTA
  RQUOTA

  This attribute tracks building quota if it is implemented.  It is
  settable in-game only by a wizard, and is only visible to wizards.
& NON-STANDARD ATTRIBUTES
  NON-STANDARD ATTRIBUTES
  Objects now have the capability of having an unlimited number of
  attributes.  These attributes can have any name.  In order to preserve
  backward compatibility, the VA-VZ, WA-WZ, and XA-XZ attributes still
  exist in their previous form, and are set like a normal attribute.
  To set a new style attribute, you use the form
      &<attribute name> <obj> = <value>  OR
      @_<attribute_name> <obj> = <value> OR
      @set <obj> = <attribute_name>:<value>
  All attributes have the ability to be used in attribute locks (see help
  @lock).  Attributes also have the new ability to be 'owned' independent
  of object ownership (see help ATTRIB-OWNERSHIP).  All attributes
  can be addressed in get() as well as in edit, and %-substitute form,
  as well as accessed via the V-function.
& ATTRIB-OWNERSHIP
  ATTRIBUTE OWNERSHIP
  The first person to create an attribute on an object is said to 'own'
  that attribute.  You must control the object in order to create an
  attribute on it.  ***OWNERSHIP OF ATTRIBUTES IS NOT CHANGED WHEN AN
  OBJECT IS @CHOWNED***  This allows for 'locks' which cannot be faked
  as the person who controls the lock and the person who controls the
  attribute MUST be the same for the lock to succeed.  It is also
  possible to 'freeze' or 'lock' an attribute so that new owners of the
  object can not tamper with it.  This allows 'standard' commands on
  objects and other neat stuff.  Attribute locking is controlled by the
  new command @atrlock and attribute ownership can be changed via the
  @atrchown command.
& BEING KILLED
  BEING KILLED

  Getting killed is no big deal. If you are killed, you return to
  your home, and  all things you carry return to their homes. You
  also collect 50 pennies in insurance money (unless you have >= 10000
  pennies or you were killed via the Wizard slay command). See MONEY.
  Generally, killing is not encouraged unless absolutely necessary.
  (Note: Killing a wizard is a quick way to discover the many uses of
  the @boot command...  and killing anyone can be very rude.)
& BOGUS COMMANDS
  BOGUS COMMANDS

  Bogus commands can be made using exits. For example, to
  make a 'sit' command,  one could "@open sit", then "@link sit=here"
  (because unlinked exits can be  stolen), "@lock sit=me&!me"
  (impossible to be both at once, therefore always fails), and "@fail
  sit=You sit on the chair."; "@ofail sit=sits on the chair.".  Since
  nobody can go through it, it always fails. The @fail message is
  displayed  to the player, and the @ofail message (preceded by the
  player's name) to  everyone else.

  A better way to do user-defined commands is to use $comands on objects.
  These are set using &<attrib> <object>=$<command pattern>:<actions>
  If something a user types matches the command pattern, the actions are
  executed. In order to execute a $command, you must pass the object's
  uselock. Otherwise, you will get a "Permission denied." message.

& CONTROL
  CONTROL

  There are 3 rules to controlling objects:
   1) You control anything you own.
   2) A wizard controls everything.
   3) Anybody controls an unlinked exit, even if it is locked.

  Builders should beware of 3, lest their exits be linked or stolen.
& COSTS
  COSTS

  These are usually:

          kill: 10 pennies (or more, up to 100 pennies)
          page: 1 penny
          @dig: 10 pennies
          @create: 10 pennies (or  more, up to 505M),
              (sacrifice value=(cost/5)-1.)
          @find: 100 pennies
          @search: 100 pennies
          @entrances: 100 pennies
          @link: 1 penny (if you  didn't already own it,
                          +1 to the previous owner).
          @open: 1 penny (2 pennies if linked at  the same time)

  Type '@config' to get the costs for the particular MUSH you are on.
& DROP-TO
  DROP-TO
  When the @link command is used on a room, it sets a drop-to
  location.  Any object dropped in the room (if it isn't STICKY) will
  go to that location.  If the room is STICKY, the drop-to will be
  delayed until the last person in the room has left.
& EXITS
  EXITS
  An exit links one room to another room.  If an exit is set DARK it will
  not show up in the list of obvious exits in a room.
& FAILURE
  FAILURE

  You fail to use a thing when you cannot take it (because its lock
  fails). You  fail to use an exit when you cannot go through it
  (because it's unlinked or  locked). You fail to use a person when
  you fail to rob them, but you can't rob in a mush. You fail to use
  a room when you fail to look  around (because it's locked).
  See ATTRIBUTES, @fail and @ofail.
& FLAGS
  FLAGS
  @set <object> = <Flags> to set, @set <object> = !<Flag> to
  reset.  Everything in the universe of this MUSH (Rooms, Exits,
  Objects, Players, etc...) are represented in the same way at the
  program level.  A room merely has the room flags set and a player
  has the player flags set.  In addition, flags also give objects
  abilities or qualities.  For instance, a wizard has the wizard flag
  set. That is what lets the program know he may use wizard
  abilities.  An object or room may have the dark flag set. In the
  case of an object, this makes the object invisible to normal
  eye-sight.  In the case of a room, the room becomes too dark to see
  other objects or players.
  For more specific information on a particular flag, request help on
  a flag title. Example: help ENTER_OK

  To get the list of flags, do "help flag list"

& FLAG LIST
Flag  Title           Flag  Title              Flag  Title
-----------------------------------------------------------------------
  A - Abode, Ansi    C - Chown_Ok        D - Dark
  E - Exit (type)    F - Floating        G - Going
  H - Haven        I - Inherit        J - Jump_Ok
  L - Link_Ok        M - Monitor        N - Nospoof, No_Tel
  O - Opaque        P - Player (type)    Q - Quiet
  R - Room (type)    S - Sticky        T - Temple
  U - Unfindable    V - Visual        W - Wizard
  X - Safe              Z - Zone

  a - Audible        b - Debug        c - Connected
  d - Destroy_Ok    e - Enter_Ok        g - Gagged
  h - Halt        l - Listener        m - Myopic
  n - No_Command    p - Puppet        r - Royalty
  t - Transparent    u - Suspect        v - Verbose
  x - Terse        z - Startup
---------------------------------------------------------------------

& DEBUG
  Flag: DEBUG  (all types)

  The DEBUG flag is used for debugging MUSHcode. It is meant to be used
  in conjunction with the VERBOSE flag. If an object is set DEBUG, all
  parser evaluation results will be shown to the object's owner, in the
  format: #<object dbref>! <string to evaluate> => <evaluated string>
  Note that verbose output is "#obj]" - debug output is "#obj!".

  Because the parser does recursive evaluations, you will see successive
  messages evaluating specific parts of an expression. This enables you
  to pinpoint exactly which evaluation is going wrong.

  Objects run under this flag are quite computationally expensive. Thus,
  only wizards and royalty may set it, although they can set it on objects
  they do not own (provided they control those objects).

  During a DEBUG evaluation, the flag is temporarily reset; therefore,
  a test for HASFLAG(), FLAGS(), etc. in the debug execution will show
  that the DEBUG flag is not set (although the actual output will be
  correct.)

  See "help DEBUG2" for more.
& DEBUG2

  Create test, and set it DEBUG.

  > @va test=$wc *:"String %0 has [strlen(%0)] letters and [words(%0)] words.
  > test This is my test string
  #14! String %0 has [strlen(%0)] letters and [words(%0)] words. => String
       This is my test string has 22 letters and 5 words.
  #14! strlen(%0) => 22
  #14! %0 => This is my test string
  #14! words(%0) => 5
  #14! %0 => This is my test string
  Test says, "String This is my test string has 22 letters and 5 words."

& NO_COMMAND
  Flag:  NO_COMMAND  (all types)

  The NO_COMMAND flag disables the checking of $-commands on an object.
  Most MUSHes will be configured to automatically set this flag on rooms
  and players. The server runs faster when fewer objects are checked for
  $-commands; thus, any object which does not have $-commands on it should
  be set NO_COMMAND.
& ANSI
  Flag:  ANSI  (players)

  When set on a player, this flag bold-hilites the names and owners
  of attributes when the player "examines" an object. This makes it
  much easier to pick out where attributes begin and end, when examining
  complex objects. You must be using a terminal which supports ANSI
  control codes in order for this to work.
& MONITOR
  Flag:  MONITOR  (players)

  When set on a player, this flag notifies that player when anyone
  connects to or disconnects from the MUSH. It is valid only for players,
  and must be set by a wizard (although royalty may set themselves MONITOR).
& AUDIBLE
  Exits that are AUDIBLE propagate sound to their destinations. In
  other words, any message - emit, say, or pose - that is heard in the
  source room of the exit is passed on to the contents of the exit's
  destination room. The message is prepended with the exit's @prefix
  attribute; if there is no @prefix, the default is used:

  "From <name of the exit's source room>,"

  Messages matching a certain pattern may be filtered out by using
  @filter on an exit; read 'help @filter' for more.

  In order for exits in a room to propagate sound, the room must also
  be set AUDIBLE. If the room is audible, exits that are audible show
  up on a @sweep, even if they are set DARK.

  See "help AUDIBLE2" for more.

& AUDIBLE2
  This flag is also valid for things. If an object is set AUDIBLE,
  any messages which originate from its contents will be broadcasted
  to the outside world. This makes it very simple to program vehicles.
  Like AUDIBLE on exits, the message is prepended with the thing's
  @prefix attribute, and messages matching certain patterns may be
  filtered with @filter. If there is no @prefix, the message will be
  prepended with "From <name of AUDIBLE object>,"
  The AUDIBLE object does not receive its own propagated messages.

  The AUDIBLE flag allows most "emitters" (objects that listen for
  messages and broadcast them to other rooms) to be eliminated. The
  message is propagated only to the next room and no farther, so
  there is no danger of looping.
& LISTENER
  LISTENER
  When set on a thing, this flag activates the ^ listen patterns on
  the object. Objects which have ^ listen patterns but are not set
  LISTENER do not check those patterns, although they are flagged
  on a @sweep as listening.
& STARTUP
  STARTUP
  This flag is automatically set or reset when you set or clear the
  STARTUP attribute on something. Players may not set this flag.
  The presence of this flag just shows that an object has a STARTUP
  attribute on it.
& MYOPIC
  MYOPIC
  Myopic is a flag which suppresses the printing of an object's dbref
  number and abbreviated list of flags when it is looked at. It makes
  the world appear like you don't control any of it, even if you're a
  wizard or royalty. It's useful if you don't like to see object numbers.
  This flag is only valid for players; objects belonging to MYOPIC
  players are automatically considered to be MYOPIC.

& INHERIT
  INHERIT
  Inherit is a security flag used to prevent objects without authorization
  from using @force, @set, and @trigger on other objects.
  Authorization is successful if:

     1. The enactor is WIZARD.
     2. The enactor's owner is INHERIT.
     2. The enactor is INHERIT.
     3. The target is not INHERIT.

  Only INHERIT or WIZARD objects may force their owners. Players can
  always @force, @set, and @trigger their objects.

  Read "help Inherit2" for more.

& INHERIT2

  Authorization is only denied if the enactor is neither a player nor
  INHERIT, and the target is WIZARD, INHERIT, or is a player.
  The INHERIT protection against @trigger may be overridden by setting
  the target object LINK_OK.
  Objects which are WIZARD are not subject to any special criterion,
  although they are automatically considered to be INHERIT.
  The normal criteria for object control still apply.

  For zoned objects, the INHERIT flag protects against an object from
  being controlled by anything not owned by its owner. This prevents
  someone who controls a zone from doing things like @forcing an
  INHERIT object to @force its owner.

& VERBOSE
  VERBOSE
  An object set VERBOSE echoes the commands it executes to its owner
  before executing them. This differs from the PUPPET flag in that the
  owner sees the command itself, rather than the output from the command.
  This flag is extremely useful in debugging, especially if used in
  conjunction with the PUPPET flag. VERBOSE output follows the format
  "#<object>] <command>". Something like "#1300] @trigger me/va" is a
  good example of typical VERBOSE output.

& TERSE
  TERSE
  When an object is set TERSE, it does not see the descriptions or
  success/failure messages in rooms. This is a useful flag if you're
  on a slow connection or you're moving through a familiar area and
  don't want to see tons of text. This flag is only valid for players;
  objects belonging to TERSE players are automatically considered to
  be TERSE.

& SUSPECT
  SUSPECT
  This flag is only settable by wizards. Players with this flag have
  their connects, disconnects, name changes, and kills reported to
  all connected wizards.
& SAFE
  SAFE
  This flag, when set on an object, prevents the object from being
  destroyed via the @destroy command. The "@nuke" command must be
  used to recycle the object. Valuable objects should be protected
  by this flag.
& NO_TEL
  NO_TEL
  The NO_TEL command prevents objects in a room from being @teleported;
  mortals in the room cannot use @teleport, nor can other objects
  @teleport them out. This flag is checked on the "absolute room" of an
  object; thus, if you are in a container in a room which is NO_TEL,
  you cannot use @teleport from that container. There is no way to
  get out of a NO_TEL room except by exiting in some "normal" manner,
  or by going "home". Puzzle rooms, prisons, and similar locations would
  probably benefit from this flag.
& ROYALTY
  ROYALTY
  If this flag is set on any type of object, then that object will
  be able to @tel and examine as if it was a wizard. Royalty players
  do not need money, nor are they affected by quotas or restricted
  building. Royalty is not able to change things like a wizard could.
  Only wizards may set it on players, although players who are ROYALTY
  may set their objects ROYALTY.
& TRANSPARENT
  TRANSPARENT
  If this flag is set on an exit, when a player looks at the exit they
  will see the description and contents of the destination room following
  the exit's description.  The exit list and succ/fail messages of the
  room will NOT be displayed.
  If this flag is set on a room, it will display exits in "long" format.
  Instead of putting all the exits on one line under "Obvious exits:"
  it prints each exit on a line by itself, in the format:
  <Exit Name> leads to <Exit Destination>.
  Thus, you might have:
     Obvious exits:
     South leads to Joe's Room.
     East leads to City Park.
  instead of
     Obvious exits:
     South  East
& ABODE
  ABODE  If a room is set ABODE, any player can set his home there,
  and can set the homes of objects there.  It does not mean that a
  player can open an exit to that room, only that they can set their
  home there.  This flag should not be set unless you want to make the
  room a public 'living area'.
& CHOWN_OK
  CHOWN_OK  This flag, when set, allows you to transfer ownership to
  another player. To set it, you must be carrying the object. You
  also have to be in the room if you want to set this flag on rooms
  or exits.  After this flag is set, the new player may gain
  ownership of the object by using the @chown command (See @chown).
& CONNECTED
  CONNECTED  This flag applies only to players and it shows if the
  player is connected or not. Thus, each time you are connected to
  the game, you should see the 'c' flag set, otherwise, you are DEAD!
  You cannot reset this flag, and it is used internally by the code
  for things like tabulating players for the WHO list, etc.
& DARK
  DARK      If a room is DARK, then no items are shown when a person
  'looks' there. If a thing is DARK, then "look" does not list that
  object in the room's Contents:, and if an exit is DARK, it doesn't
  show up in the Obvious Exits: list.  Puppets and objects that can
  listen cannot be DARK.

  There is a config option for "full invisibility": players and objects
  that are dark will be slightly disguised in speech and poses.  Such
  actions by these objects will show as being from Someone or Something
  depending on whether it was an object or wizard player.

  See 'help DARK2' for more.

& DARK2
  Royalty and wizards can set themselves DARK to hide from the WHO list
  and related functions. DARK on royalty is not a "true" dark -- the
  player still appears in the room contents list, still has a connect
  and disconnect message, and, for all purposes, is just as visible as
  any normal player, except for the fact that the DARK royal does not
  appear on the WHO.

  Wizards who are DARK "disappear" completely -- they are not on the WHO
  list, do not announce connects and disconnects, etc.
& DESTROY_OK
  DESTROY_OK   When set on an object, it allows any player to destroy
  it as long as the object is not locked against them. This is good
  for things like notes, whereby the recipient can destroy the note
  after reading it, instead of having to look for you to destroy it.
& ENTER_OK
  ENTER_OK   If an object or person is ENTER_OK, other players may
  enter the object or person by using 'enter <object/person>.
  Only objects which are ENTER_OK may be entered, regardless of the
  enter lock. Players must also have the ENTER_OK set if they wish to
  be able to receive  things given to them by other players via the
  'give <player> = <object>'.
& GENDER
  GENDER    @set me=sex:<unassigned|male|female|neuter>. Default
  unassigned. If a player's gender is set, %-substitutions will use
  the appropriate pronoun for that player. Only  meaningful for
  players.
  See SUBSTITUTIONS.
& GOING
  GOING     Used internally for the @destroy command, it is set on
  rooms that are set to be destroyed. In the event that a player
  decides they don't want to destroy the room after all then they can
  unset it.
& HAVEN
  HAVEN     @set here=haven;@set me=haven. If a room is HAVEN, you
  cannot kill in that room. If a player is set HAVEN, he cannot be
  paged.  Bummer.
& LINK_OK
  LINK_OK   If a something is LINK_OK, anyone can link exits to it (but
  still not from it). Also, LINK_OK overrides the INHERIT protection
  against @trigger (although not @force or @set).
  See @link, INHERIT.
& UNFINDABLE
  UNFINDABLE

  If a player is set UNFINDABLE, he cannot be found by the @whereis
  command. You also cannot use loc(), locate(), and similar functions
  to find his location.

  If a room is set UNFINDABLE, you cannot locate any of its contents
  via any means (@whereis, the loc() function, etc.)

  If a wizard is set UNFINDABLE, and he is idle past the allowable
  maximum idle time, he will be set DARK automatically.
& FLOATING
  If a room is set floating, you will not be notified every 10
  minutes or so that you have a disconnected room.
& OPAQUE
  OPAQUE   When set on a player, it prevents other players from
  seeing what you are carrying in your inventory. This applies to
  everyone and everything, even wizards and royalty, or to stuff
  that you own.
& PLAYER
  PLAYER The PLAYER flag identifies you as a player. This flag cannot
  be reset by any player, not even a Wizard (not, yet, anyway
  *grin*).  It is used mainly by the mush code to identify your
  commands, check for validity of commands or locks etc. Generally,
  just pretend it isn't even there.
& JUMP_OK
  When a room is set JUMP_OK, then that room can be teleported into
  by anyone. See @teleport.
& PUPPET
  PUPPET   @set <object> = puppet. Causes an object to grow eyes and
  ears, and relay all it sees and hears to its owner.
  See: @force, PUPPETS
& ROOM
  ROOM   This flag is automatically set on rooms when you @dig a new
  room. It cannot be changed. Rooms have the added advantage that
  they can be saved from destruction by setting the room to !GOING
  (SEE GOING).
  However, this can only be done if no other room/object was created
  that overwrote your room when it was set for destruction.
& VISUAL
  VISUAL The flag a lot of players have been waiting for. When set on
  your object, it allows other players to examine it and see all the
  object's attributes as if they owned the object. They cannot make
  any changes to the object.
& QUIET
  QUIET     This flag when set on yourself prevents you from hearing
  the 'set' or 'triggered' messages from any objects you own.  When
  set on an object, only that object will not relay its messages.
& HALT
  HALT    While this flag is set, the object cannot perform any mush
  actions, listen, be triggered, etc.
& GAGGED
  GAGGED   When set on a player, it disables him from doing anything
  except moving and looking.  He cannot talk, page, build, pose, get
  or drop objects. (Yet another consequence of annoying the wizards.)
  Only wizards can set this flag.
& STICKY
  STICKY    If a thing is STICKY, it goes home when dropped (See HOMES).
  It also goes home when an object carrying it teleports or goes home.
  If a room is STICKY, its drop-to is delayed until the last person leaves
  (See DROP-TOs). This flag is only meaningful for things and rooms.
& TEMPLE
  TEMPLE  If a room is TEMPLE, you can sacrifice things for pennies by
  dropping them there. It has no meaning for players, things, or
  exits. Only wizards can set this flag.
& BUILDER
  BUILDER If a player has the BUILDER flag set, it means that all the
  building commands will work for them.  Without it, you can only
  explore the world but not add to it. This is only settable by
  Wizards.
& WIZARD
  WIZARD    If a person is WIZARD, they are a wizard, unkillable,
  subject to fewer restrictions, and able to use wizard commands.
  In general, WIZARDs can do anything using #<number> or *<player>.
  Only player #1 can set and unset the WIZARD flag of other players.
  No WIZARD can turn their own WIZARD flag off.
& NOSPOOF
  NOSPOOF   If an object is set NOSPOOF, @emits, @oemits, @remits and
  @pemits will be distinctively tagged to help prevent spoofing. This
  flag is only valid for players; objects belonging to NOSPOOF players
  are automatically considered NOSPOOF. Beware: the output format of
  NOSPOOF can mess up @listen and ^ patterns, giving unexpected results.
  See SPOOFING, @emit, @pemit, @remit, and @oemit.
& LISTENING
  There are two ways to listen for something in a room. The easiest way
  is to use a combination of @listen and @ahear/@aahear/@amhear. The
  second way is to use a "^" pattern in an attribute, similar to the way
  "$" is used for user-defined commands. This takes the form of:
  &<attribute> <object> = ^<pattern>:<action>
  The criterion for triggering a pattern-listen is the same as that for
  triggering an @ahear - the object cannot trigger its own listen patterns.
  Listen patterns are checked after the object's normal @listen attribute.
  To activate the listen patterns, the LISTENER flag must be set on the
  object. Only things may have listen patterns.
  Example:
  > &TEST object = ^* screams.:"Hello, %0.
  Object - Set.
  > :screams.
  Amberyl screams.
  > Object says "Hello, Amberyl."

& HERE
  HERE    The word 'here' refers to the room you are in. For example,
  to rename the room  you're in (if you control it), you could enter
  "@name here= <new name>".
& HOMES
  HOMES    Every thing or player has a home. This is where things go
  when sacrificed,  players when they go home, or things with the
  STICKY flag set go when dropped  (See STICKY). Homes are set with
  the @link command. A thing's home defaults to  the room where it
  was created, if you control that room, or your home. You can link
  an exit to send players home (with their inventory) by
  "@link <dir>=home".  Drop-tos can also be set to 'home'.
  See DROP-TO and @link.
& LINKING
  LINKING  You can link to a room if you control it, or if it is set
  LINK_OK or ABODE. Being able to link means you can set the homes of
  objects or yourself to that  room if it is set ABODE, and can set
  the destination of exits to that room if it is LINK_OK.
  See LINK_OK, ABODE and @link.
& ME
  ME   The word 'me' refers to yourself. Some things to do when
  starting out:
  1) give  yourself a description with
  "@describe me=<description>", then look at yourself  with
  "look me".
  2) set your gender, if you wish it known, with "@set me=male" or
  "@set me=female"  (or "@set me=neuter" to be an 'it').
& MONEY
  You will be given a daily allowance of pennies to spend in anything
  you can find to spend it on.  See COSTS and SACRIFICING.
& PUPPETS
  PUPPETS   An object is made into a puppet by doing
  @set [object]=puppet.  Once an object is a puppet it will relay all
  that it sees and hears to its master.  All objects created by a
  puppet are owned by its master.  When puppets spend or earn pennies
  they are also taken from and given to its master. In order to
  prevent puppets from screwing up puzzles objects may have the key
  flag set, which will prevent puppets from picking the object up. A
  puppet may be commanded by its master by:
  @force [object]=command or by the shorthand version,
  [name/# of puppet] command

  example:
  @force fred="hi there. or
  fred "hi there. or
  #4342 "hi there.
& ROBBERY
  ROBBERY   Robbing is not allowed on this MUSH. If you really
  need money, ask your friendly neighborhood wizard, or @destroy
  some objects you no longer need.
& SACRIFICING
  SACRIFICING    You sacrifice a thing by dropping it in the temple.
  Sacrificing an object gives you the value of an object. You can't
  sacrifice something you own, and get money for it. If you have
  >= 10000 pennies, all sacrifices are worth only 1 pennies. The
  sacrifice value of a thing is set at creation by
  "@create frob=cost", by the formula value=(cost/5)-1. Only a wizard
  can change the value of an object, once created.
& SUBSTITUTIONS
  SUBSTITUTIONS  All messages may contain %-substitutions, which
  evaluate to gender-specific pronouns if the player's gender is set.
  They are:
  %s (subjective) = Name, he, she, it.
  %o (objective) = Name, him, her, it.
  %p (possessive) = Name's, his, her, its.
  %N (player's name) = Name.
  If you need a '%', use %%.
  Ex. '@ofail teapot=burns %p hand on the hot teapot.'
  See GENDER.

  Other substitutions, such as %va-%vz, %wa-%wz, %xa-%xz, and %0-%9
  may also be used and will be evaluated to v(?) (See V-FUNCTIONS)
  where ? is a-z or 0-9. In these substitutions and pronoun substituions,
  if the first letter of the name is capitalized, the first letter of
  the substitution will also be capitalized.

  Other possible substitutions are:
  %# (player number) = #<actor's number>. Equivalent to num(%N)
  %! (object number) = #<message holder's number>. Equivalent to num(me)
  %l (location number) = #<actor's location>. Like loc(%N).  This
     works even if the LOC() function would normally not, since the
     enactor has "volunteered" his location by triggering another object.
  %r (newline) = Carriage return and newline in output. Note that this
     counts as two characters, in functions like strlen().  (puts "\r\n")
  %t (tab) = Tab character in output.
  %b (blank) = Space in output.
  %_<attrname> This will give you the discreet value of ANY attribute you can
     read on the object.

& SUCCESS
  SUCCESS   You successfully use an object when you take it. You use
  an exit successfully  when you go through it. You successfully use
  a room when you look around. See  ATTRIBUTES, @SUCCESS and @OSUCCESS.
& TYPES OF OBJECTS
  TYPES OF OBJECTS    There are 4 types of objects: things, players,
  exits, and rooms. The first  letter following an object's ID number
  indicates the type: P(layer), E(xit),  R(oom), otherwise, thing.
  Things are inanimate objects that can be carried.  Players are
  animate objects that can move and carry. Exits are the means by
  which objects move from room to room. Rooms are locations that
  contain objects and linked exits.
& ENACTOR
  The enactor is the thing that is doing something.  If one of your
  Objects does something (through a @force or @trigger) it is the
  enactor.  If one of your links or rooms does something (through a
  @Asuc, @Afail or @Aenter) then YOU are the enactor and the action
  happens as if you typed it in directly.  To determine the enactor
  create an object to listen for the action with @ahear = :[v(N)].
& STACK
  V(0) through V(9) are the ten items on the stack.  Stack values can
  be set by either parameters after an @trigger or asterisk substitution
  in pattern matching.
  Example: @listen item=* foo *; @ahear item= [v(1)] bar [v(0)].
& @switch
  @switch [/<switch>] <string> = <expr1>, <action1> [,<exprN>,
                                 <actionN>]... [,<default>]
  This is a general control structure which can be thought of as a
  combination if/then/else and switch/case. It compares <string> against
  the expressions <expr1>, <expr2>, ..., <exprN> until a match is found.
  It then performs the associated action list. It matches all expressions
  which conform to the string pattern, and executes all the associated
  actions. (To match only the first, use "@select"). If no match is found,
  the <default> is executed. Wildcards and the < and > operators are
  allowed in the targets.
  This is the default. @switch also can take two switches, /all and
  /first. The default is /all; /first is equivalent to @select.
  Example:
    > @va thing = $foo *:@switch %0=*a*,:acks,*b*,:bars,*c*,:cheeps,:glurps
    > foo abc
    thing acks
    thing bars
    thing cheeps
    > foo xxx
    thing glurps

& @select
  @select <string> = <expr1>, <action1> [,<exprN>, <actionN>]... [,<default>]
  This is similar to @switch, except it only executes the action
  associated with the first expression which matches <string> - the
  targets are mutually exclusive. If no target is matched, the default
  actions are executed. This is equivalent to "@switch/first".
  Example:
    > @va thing = $foo *:@select %0=*a*,:acks,*b*,:bars,*c*,:cheeps,:glurps
    > foo abc
   thing acks
    > foo xxx
   thing glurps

& @trigger
  @trigger can pass control and data (on the stack) between or within
  items.
  Example: @va item=@trigger me/vb=[v(0)]; @vb item = :[v(0)];
  @trigger item/va=foo.
& VERBS
  For most verbs there are three forms: Verb (what the Enactor sees),
  Overb (what others in the area see) and Averb (the action to be
  taken when the event happens). Example: @Drop, @Odrop and @Adrop
& V-function
  The V() function is used to get attributes on an object, as
  well as another form of writing certain %-substitutions.
  v(N) is the name of the enactor, v(#) is the number of the
  enactor, v(!) is the number of the current object,
  v(L) is the number of the enactor's location, v(0) to v(9)
  are the stack variables. These are equivalent to %N, %#, %!,
  %L, and %0 to %9, respectively.

  When used to get attributes, this function takes the form
  V(<name of attribute>). This is equivalent to GET(me/<attribute>)
  but V() is faster.

& @scan
  @scan[/<switch>] <command>

  @scan gives you a list of all objects containing $commands (user-defined
  commands) which could match <command>. If given no switches, it checks
  you, your possessions, your location, objects in your location, the
  zone/parent room of your location, your zone, and objects in the master
  room. It does NOT stop when it gets a match, but rather, finds all
  possible matches. It also tells how many commands on each object were
  matched. It does NOT scan objects that you do not control and are not
  set VISUAL.

  This command can take four switches:
     /room     --   just matches on your location and objects in it.
     /self     --   just matches on you and anything you're carrying.
     /zone     --   just matches on zones of your location and yourself.
     /globals  --   just matches on objects in the master room.
& @sweep
  @sweep [connected | here | inventory | exits ]

  @sweep gives you a list of all objects/players that are listening in
  the room you are currently in, as well as the objects you are
  carrying. Most objects only listen for a particular string or
  phrase, so they normally do not pose a problem if you need privacy.
  You will have to be careful of players and puppets since they will
  hear everything you say and do. (And might post the same to r.g.m!)
  AUDIBLE exits are also shown on an ordinary sweep, if the room is
  also AUDIBLE. (Audible exits aren't active unless the room is audible).

  The four command options can also be used as switches (i.e., you
  can use "@sweep/connected" instead of "@sweep connected").
  If the connected flag is given, only connected players and puppets
  owned by connected players will be shown in the @sweep.
  The "here" and "inventory" flags check only your location or
  inventory, respectively. "exits" only checks for AUDIBLE exits.

& @cpattr
  @cpattr <obj>/<attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]

  This command is used to copy <attr> on <obj> to the object-attribute
  pairs in a comma-separated list. For example:

  @cpattr test/va = test/vb, cube/va, tribble/foo

  would copy the VA attribute from object "test" to VB on "test",
  VA on "cube", and FOO on "tribble".  <objN> is matched as if
  you were performing a @set on it.
& SPOOFING
  Spoofing is the act of making other characters think that a person
  said or did something that they did not.  This is very easy to
  accomplish, and has some good effects, which is why it is allowed.
  Overabuse of this feature will result in its being made a wizard
  only feature. (Not to mention perhaps bringing down a few @toads on
  people) See also @emit, @pemit, @remit, @oemit and NOSPOOF.

& @function
  @function [<function name>=<object>,<attribute>]

  When used without any arguments, this command lists all global
  user-defined functions. For wizards and others with the Functions
  power, it also lists the dbref number and attribute corresponding
  to the listed functions.

  Otherwise, this command defines a global function with the name
  <function name>, which evaluates to <attribute> on <object>.
  <object> can be anything that the player using the @function command
  can examine. <function name> must be 30 characters or less.

  When something is defined via @function, normal mortals don't have to
  be able to read <object>'s <attribute> in order to use it - to the
  user, such functions behave exactly like the functions built into
  the MUSH server. This hides the details of the implementation from
  the user.

  For more details on global user-functions, read "help @function2".

& @function2
  Functions defined via @function should follow the format used by
  UFUN() - %0 is the first argument passed, %1 is the second argument
  passed, and so forth.

  Example:

    > &WORD_CONCAT #10=%0 %1
    > say "[ufun(#10/word_concat,foo,bar)]
    You say, "foo bar"

    > @function wcat = #10, word_concat
    > say "[wcat(foo,bar)]
    You say, "foo bar"

  Global user-defined functions are not automatically loaded when the
  game is restarted. In order to avoid objects which attempt to use
  functions that have not been loaded, a @startup containing @function
  commands should be set on a wizard object with as low a dbref number
  as possible; object #1 (generally God) is suggested for this use.

& FUNCTIONS
  Functions are specialized commands used to manipulate strings and
  other input. Function take the general form:  [FUNCTION(<input>)]

  The brackets are used to delimit and force evaluation of the function
  (or nested functions). The brackets can also be used to group functions
  for the purposes of string concatenation. In general, more than one pair
  of brackets is not required, but liberal use of them makes code easier to
  read. You can nest an arbitrary number of brackets.

  Examples:
      > say [first(rest(This is a nice day))]
      You say, "is"
      > @va me=This is a
      Wizard - Set.
      > @vb me=nice day
      Wizard - Set.
      > say [first([rest([v(va)] [v(vb)])])]
      You say, "is"

  See "help FUNCTIONS2" for more.

& FUNCTIONS2

  A list of available built-in functions can be obtained via the command
  "@config/functions". In the help text, the list is under the topic
  "FUNCTION LIST".

  In addition to these built-in functions are MUSH-defined "global user
  functions."  These are defined by wizards or those with the "Function"
  power, via the "@function" command. To the user, they act just like
  the built-in game functions. For details on global user functions,
  see "help @function".

& FUNCTION LIST

  Several major variants of functions are available. The help topics
  are listed below, together with a quick summary of the function type
  and some examples of that type of function.

  Attribute functions: attribute-related manipulations (GET, UFUN)
  Boolean functions:  produce 0 or 1 (false or true) answers  (OR, AND)
  Dbref functions: return dbref info related to objects (LOC, LEXITS)
  Floating point functions: floating point math (SIN, ROUND)
  Information functions:  find out something about objects (FLAGS, MONEY)
  List functions:  manipulate lists (REVWORDS, FIRST)
  Math functions:  number manipulation, generic or integers only (ADD, DIV)
  String functions:  string manipulation (ESCAPE, FLIP)
  Utility functions: general utilties (TIME, COMP)

  The command "@config/functions" lists all of the game's built-in functions.

& Attribute functions
  All these functions access attributes on an object.

  eval()        filter()      fold()        get()         grep()
  lattr()       obj()         poss()        subj()        ufun()
  v-function    xget()          zfun()

& Boolean functions
  Boolean functions all return 0 or 1 as an answer.

  and()         eq()          gt()          gte()         lt()
  lte()         neq()         not()         or()          xor()

& Dbref functions
  Dbref functions return a dbref or list of dbrefs related to some value
  on an object.

  con()         home()        lcon()        lexits()      loc()
  locate()      lsearch()     next()        num()         owner()
  parent()      pmatch()      rnum()        room()        where()
  zone()

& Information functions
  Information functions return values related to objects.

  andflags()    conn()        controls()    elock()       flags()
  hasflag()     idlesecs()    lock()        lstats()      lwho()
  mail()        money()       name()        nearby()      orflags()
  type()        visible()

& Floating point functions
  Floating point functions operate on floating point numbers. Most of
  them return a floating-point number as a result. Floating point
  results can have at most 6 decimal places of precision.

  These functions only exist if floating point computation is enabled.
  Check "@config" to see if they are.

  acos()        asin()        atan()        ceil()        cos()
  e()           exp()         fdiv()        floor()       log()
  ln()          pi()          power()       round()       sin()
  tan()

& List functions
  List functions take at least one space-separated list of words and
  return transformed lists or one or more members of those lists.

  after()       before()      extract()     first()       iter()
  match()       member()      remove()      rest()        revwords()
  setdiff()     setinter()    setunion()    shuffle()      sort()
  splice()      wordpos()     words()

  Some list functions also operate on arbitrary separators. A space
  is used if no separator is given, usually.

  delete()    element()    index()        insert()      items()
  replace()

& Math functions
  Math functions take one or more numbers and return a numeric value.

  These functions can taken both integers and floating point numbers:

  add()         max()         min()         mul()         sign()
  sub()         trunc()

  These functions operate only on integers (if passed floating point
  numbers, the numbers will be truncated to integers):

  abs()         dist2d()      dist3d()      div()         mod()

& String functions
  String functions take at least one string and return a transformed
  string, parts of a string, or a value related to the string(s).

  alphamin()    alphamax()    art()         capstr()      cat()
  comp()        edit()        escape()      flip()        lcstr()
  ljust()    merge()       mid()         pos()         repeat()
  rjust()       scramble()    secure()      space()       squish()
  strcat()      strlen()      switch()      ucstr()

& Utility functions
  These functions don't quite fit into any other category.

  beep()        convsecs()    convtime()    create()      die()
  dig()         isnum()       isword()        lnum()        open()
  r-function    rand()        s-function    secs()        setq()
  time()

& ANDFLAGS()
  andflags(<object>,<list of flags>)

  This function returns 1 if <object> has all the flags in a specified
  list, and 0 if it does not. The list is specified with a single letter
  standing for each flag, like the output of the FLAGS() function. A '!'
  preceding a flag letter means "not flag".

  Thus, ANDFLAGS(me,WD) would return 1 if I was set WIZARD and DARK.
  ANDFLAGS(me,W!Dc) would return 1 if I was set WIZARD, not DARK,
  and CONNECTED.

  If a letter does not correspond to any flag, <object> doesn't have
  it, so the function returns 0. There can be an arbitrary number of
  flags. Do not put spaces between flag letters.

& ORFLAGS()
  orflags(<object>,<list of flags>)

  This function returns 1 if <object> has at least one of the flags in
  a specified list, and 0 if it does not. The list is specified with a
  single letter standing for each flag, like the output of the FLAGS()
  function. A '!' preceding a flag letter means "not flag".

  Thus, ORFLAGS(me,Wr) would return 1 if I am set WIZARD or ROYALTY.
  ORFLAGS(me,D!c) would return 1 if I am DARK or not CONNECTED.

  If a letter does not correspond to any flag, <object> doesn't have
  it, so it is simply ignored. There can be an arbitrary number of
  flags. Do not put spaces between flag letters.

& ITEMS()
  items(<list>,<single-character separator>)

  This counts the number of items in a list which uses some arbitrary
  separator. This is similar in functino to WORDS(), but you can use
  any character, not just a space.

  Example:
    > say [items(this|is|a|short|string,|)]
    You say, "5"

& ELEMENT()
  element(<list>,<item>,<single-character separator>)

  This returns the position of <item> in <list>, where <list>'s items
  are separated by <separator>. A wildcard match is done, so this
  function behaves much like MATCH().

  Example:
    > say [element(this|is|a|test|string,is,|)]
    You say, "2"

& DELETE()
  delete(<list>,<position>[,<single-character separator>])

  This deletes the item at <position> in the list. If a separator
  character is not given, a space is assumed.

  Examples:
    > say [delete(This is a long test string,4)]
    You say, "This is a test string"
    > say [delete(lemon|orange|apple,2,|)]
    You say, "lemon|apple"

& REPLACE()
  replace(<list>,<position>,<new item>[,<single-character separator>])

  This replaces the item at <position> of <list> with <new item>.
  If no separator is given, a space is assumed.

  Examples:
    > say [replace(Turn north at the junction,2,south)]
    You say, "Turn south at the junction"
    > say [replace(blue|red|green|yellow,3,white,|)]
    You say, "blue|red|white|yellow"

& INSERT()
  insert(<list>,<position>,<new item>[,<single-character separator>])

  This inserts before the item of <list> at <position> the <new item>.
  That means that <new item> then becomes the <position>th element of
  <list>. If a separator is not given, a space is assumed.

  Examples:
    > say [insert(This is a string,4,test)]
    You say, "This is a test string"
    > say [insert(one|three|four,2,two,|)]
    You say, "one|two|three|four"

& VISIBLE()
  visible(<object>,<victim>[/<attribute>])

  If no attribute name is provided, this function returns 1 if
  <object> can examine <victim>, or 0, if it cannot. If an
  attribute name is given, the function returns 1 if <object>
  can see the attribute <attribute> on <victim>, or 0, if it
  cannot.

  If <object>, <victim>, or <attribute> is invalid, the function
  returns 0.

& CONTROLS()
  controls(<object>,<victim>)

  This function returns 1 if <object> controls <victim>, or 0, if
  it does not.

  See also CONTROLS.

& SHUFFLE()
  shuffle(<word1> <word2> <word3> <...wordN>)

  This function shuffles the order of words in a list, returning a
  random permutation of its elements. "[shuffle(foo bar baz gleep)]"
  might evaluate to "baz foo gleep bar".

& SCRAMBLE()
  scramble(<string>)

  This function scrambles a string, returning a random permutation of its
  characters. For example, "[scramble(abcdef)]" might return "cfaedb".
  Note that this function does not pay any attention to spaces or other
  special characters; it will scramble these characters just like normal
  characters.

& R-FUNCTION
  r(<number>)

  The r() function is used to access "local registers", and returns
  the contents of the specified register. There are ten such registers,
  numbered 0 through 9.

  See "help SETQ()" for details about registers.

& SETQ()
  setq(<number>,<string>)

  The setq() function is used to copy strings into local registers.
  It returns a null string; it is a purely "side effect" function.

  There are ten local registers, numbered 0 through 9. They are cleared
  at the start of each new queue cycle (i.e. whenever a new command is
  evaluated). They are most useful for storing complex function evaluations
  which are used repeatedly within a single command.

  See "help SETQ2" for examples of its use.

& SETQ2

  The setq() function is probably best used at the start of the string
  being manipulated, such as in the following example:

    > &TEST object=[strlen(%0)]
    > &CMD object=$test *:"[setq(0,u(TEST,%0))]Test. %0 has length [r(0)].
    > test Foo
    Object says, "Test. Foo has length 3."

  In this case, it is a waste to use setq(), since we only use the function
  result once, but if TEST was a complex function being used multiple times
  within the same command, it would be much more efficient to use the local
  register, since TEST would then only be evaluated once.

  setq() can thus be used to improve the readability of MUSH code, as well
  as to cut down the amount of time needed to do complex evaluations.

& LJUST()
  ljust(<string>,<length>[,<fill>])

  This function pads a string with trailing characters ("left-justifies")
  so it is <length> long. If <string> is longer than <length>, the <string>
  is returned; it is not truncated. If <fill> is not specified, a space
  is used.

  Examples:

    > say [ljust(foo,6)]
    You say, "foo   "

    > say %r0[ljust(foo,6,-)]7%r01234567
    You say, "
    0foo---7
    01234567"

& RJUST()
  rjust(<string>,<length>[,<fill>])

  This function pads a string with leading characters ("right-justifies")
  so it is <length> long. If <string> is longer than <length>, the <string>
  is returned; it is not truncated. If <fill> is not specified, a space
  is used.

  Examples:

    > say -[rjust(foo,6)]-
    You say, "-   foo-"

    > say %r0[rjust(foo,6,-)]%r01234567
    You say, "
    0---foo7
    01234567"

& FILTER()
  filter([<obj>/]<attr>, <list>)

  This function returns the elements of <list> for which a user-defined
  function evaluates to "1". That function is specified by the first
  argument (just as with the ufun() function), and the element of the
  list being tested is passed to that user-defined function as %0.

  Thus, "filter(obj/attr, x1 x2 x3)" is equivalent to
  "iter(x1 x2 x3, switch(ufun(obj/attr, ##),1,##,))"

  Example:

    > &IS_ODD test=[mod(%0,2)]
    > say [filter(test/is_odd, 1 2 3 4 5 6)]
    You say, "1 3 5"

& FOLD()
  fold([<obj>/]<attr>, <list>[, <base case>])

  This function "folds" a list through a user-defined function, specified
  by the first argument to fold(), which is analogous to ufun()'s first
  argument.

  If no base case is provided, fold() passes the first element of <list>
  as %0, and the second element of <list> as %1, to the user-defined
  function. The user-defined function is then called again, with the
  result of the first evaluation being %0, and the next (third) element
  of the list as %1. This is repeated until all the elements of the
  list have been used.

  If a base case is provided, it is passed as %0, and the first element
  of list is passed as %1, to the user-defined function. The process for
  the no-base-case fold() is then used.

  See 'help FOLD2' for examples.

& FOLD2

  Examples:

    > &REP_NUM test=%0[repeat(%1,%1)]
    > say [fold(test/rep_num,1 2 3 4 5)]
    You say, "122333444455555"
    > say [fold(test/rep_num,1 2 3 4 5,List:)]
    You say, "List:122333444455555"

    > &ADD_NUMS test=add(%0,%1)
    > say [fold(test/add_nums,1 2 3 4 5)]
    You say, "15"

& SQUISH()
  squish(<string>)

  This function removes the leading and trailing spaces from a string,
  and condenses all inter-word spaces to a single space. This applies
  only to literal spaces, and not to tabs or newlines.

  Example:

    > say [squish(  foo bar  baz blech   eek )]
    You say, "foo bar baz blech eek"

& INDEX()
  index(<list>,<character>,<first>,<length>)

  This function is similar to EXTRACT(), except that an item in the
  list may be more than one word; instead of a space being used to
  separate items in the list, <character> is used. The function returns
  <length> items starting from that in the <first> position. Trailing
  spaces are trimmed. The comma cannot be used as the <character> separator.

  Examples:

    > say [index(Cup of Tea | Mug of Beer | Glass of Wine, |, 2, 1)]
    You say, "Mug of Beer"

    > say [index(%rtoy boat^%rblue tribble^%rcute doll^%rred ball,^,2,2)]
    You say, "
    blue tribble^
    cute doll"

& TRUNC()
  trunc(<string>)

  This function truncates floating point numbers to integers. It can
  also be used to return the leading numeric prefix of a string, or
  "0" if there isn't one. For example, "val(101Dalmations)"  => 101.

& ISWORD()
  isword(<string>)

  This function returns 1 if every character in <string> is a letter,
  or 0, if any character isn't a letter.  Case does not matter.

& ISNUM()
  isnum(<string>)

  This function returns 1 if <string> is a number, and 0 if it is not.
  Numbers can begin with a '-' sign (for negatives), but the rest of
  the characters in the string must be digits.

& GREP()
  grep(<object>,<attrs>,<pattern>)

  This function returns a list of attributes on <object> containing
  <pattern>.  <attrs> is a wildcard pattern for attribute names to
  search; if you want to search all attributes, use "*".

  The list returned is similar to that returned by
  @grep/list <object>/<attrs>=<pattern>

  Parsing _does_ occur before this function is invoked. Therefore,
  "special" characters will need to be escaped out.  <pattern> is
  NOT wildcard matched.
& REPEAT()
  repeat(<string>,<number>)

  This function simply repeats <string>, <number> times.  No spaces are
  inserted between each repetition.

  Example:
    > say [repeat(Test, 5)]
    You say, "TestTestTestTestTest"

& SPLICE()
  splice(<list1>, <list2>, <word>)

  This function splices <list1> and <list2> together. <list1> and <list2>
  are space-separated lists of words

  If a word in <list1> is the same as <word>, it is replaced by the word
  in the corresponding position in <list2>.  Both lists must have the
  same number of words.

  Example:
    > say [splice(foo bar baz,eek moof gleep,bar)]
    You say, "foo moof baz"

& MERGE()
  merge(<string1>, <string2>, <character>)

  This function merges <string1> and <string2>, depending on <character>.
  If a character in <string1> is the same as <character>, it is replaced
  by the character in the corresponding position in <string2>.  The two
  strings must be of the same length.

  Example:
    > say [merge(AB--EF,abcdef,-)]
    You say, "ABcdEF"

  Spaces need to be treated specially. A null character is considered to
  equal a space, for <character>.

  Example:
    > say [merge(AB[space(2)]EF,abcdef,)]
    You say, "ABcdEF"

& EDIT()
  edit(<string>, <search>, <replace>)
  edit(<string>, $, <string to append>)
  edit(<string>, ^, <string to prepend>)

  This functions in a similar way to the @edit command; instead of
  taking an attribute from an object, it takes an arbitrary string.
  The first form of the function searches <string> for <search> and
  replaces it with <replace>; the other two forms append and prepend
  text to <string>, respectively.

  See also "help @edit".
& SWITCH()
  switch(<string>, <expr1>, <list1>, [<exprN>, <listN>], ...[<default>])

  This function matches <string> against the <expr>essions, returning the
  corresponding <list>. If nothing is matched, the <default> is returned.
  This is similar to @switch/first, but instead of executing the list,
  it simply returns it. Wildcard patterns are allowed. There may be
  a maximum of ten arguments total to the function.

  Example:
    > say switch(test, *a*, foo, *b*, bar, *t*, neat, baz)
    You say, "neat"
    > say switch(ack, *a*, foo, *b*, bar, *t*, neat, baz)
    You say, "foo"
    > say switch(moof, *a*, foo, *b*, bar, *t*, neat, baz)
    You say, "baz"

& REVWORDS()
  revwords(<list of words>)

  This function reverses the order of words in a list.

  Example:
    > say revwords(foo bar baz eep)
    You say, "eep baz bar foo"

& SETDIFF()
  setdiff(<list1>, <list2>)

  This function returns the difference of two sets -- i.e., the
  elements in <list1> that aren't in <list2>. The list that
  is returned is sorted.

  Example:
    > say setdiff(foo baz gleep bar, bar moof gleep)
    You say, "baz foo"

& SETINTER()
  setinter(<list1>, <list2>)

  This function returns the intersection of two sets -- i.e., the
  elements that are in both <list1> and <list2>. The list that is
  returned is sorted.

  Example:
    > say setinter(foo baz gleep bar, bar moof gleep)
   You say, "bar gleep"

& SETUNION()
  setunion(<list1>, <list2>)

  This function returns the union of two sets -- i.e., all the
  elements of both <list1> and <list2>, minus any duplicate
  elements. Think of it as CAT() without words duplicated.
  The list returned is sorted.

  Example:
    > say setunion(foo baz gleep bar, bar moof gleep)
    You say, "bar baz foo gleep moof"

& CONVSECS()
  convsecs(<seconds>)

  This function converts seconds to a time string, based on how many
  seconds the number is after Jan 1, 1970.

  Example:
  > say [secs()]
  You say, "709395750"
  > say [convsecs(709395750)]
  You say, "Wed Jun 24 10:22:54 1992"

& CONVTIME()
  convtime(<time string>)

  This functions converts a time string to the number of seconds since
  Jan 1, 1970. A time string is of the format: Ddd MMM DD HH:MM:SS YYYY
  where Ddd is the day of the week, MMM is the month, DD is the day
  of the month, HH is the hour in 24-hour time, MM is the minutes,
  SS is the seconds, and YYYY is the year.
  If you supply an incorrectly formatted string, it will return -1.

  Example:
  > say [time()]
  You say, "Wed Jun 24 10:22:54 1992"
  > say [convtime(Wed Jun 24 10:22:54 1992)]
  You say, "709395774"

& IDLESECS()
  idlesecs(<player name>)

  This function returns the number of seconds a player has been idle,
  much as WHO does. <player name> must be the full name of a player.
  Players who are not connected have an idlesecs of "-1", as do
  dark wizards, when idlesecs() is used on them by a non-priv'ed player.

& CONN()
  conn(<player name>)

  This function returns the number of seconds a player has been
  connected. <player name> must be the full name of a player.
  Players who are not connected have a conn value of "-1", as do
  dark wizards, when conn() is used on them by a non-priv'ed player.

& PARENT()
  parent(<object>)

  This function returns the dbref number of an object's parent. You
  must control the object. The parent of a player is always #-1.

& CREATE()
  create(<object>, <cost>)

  This function creates an object with name <object> for <cost> pennies,
  and returns the dbref number of the created object.

& OPEN()
  open(<exit name>, <room>)

  This function opens an exit called <exit name> and links it to
  <room>, which must be a dbref number. It returns the dbref number
  of the new exit.

& DIG()
  dig(<name>, <exit to>, <exit from>)

  This function digs a room called <name>, and then opens and links
  <exit to> and <exit from>, like the normal @dig command. It returns
  the dbref number of the new room.

& HOME()
  home(<object>)

  Returns the object's 'home'.  This is the home for a player or thing,
  the drop-to of a room, or source of an exit.

& ROOM()
  room(<object>)

  Returns the "absolute" location of an object. This is always a room;
  it is the container of all other containers of the object. The
  "absolute" location of an object is the place @lemit messages are
  sent to and NO_TEL status determined.
  You must control the object, be a wizard or royalty, or be near
  the object in order for this function to work. The exception to this
  are players; if <object> is a player, the ROOM() function may be
  used to find the player's absolute location if the player is not
  set UNFINDABLE.

& LOCATE()
  locate(<looker>, <name>, <parameters>)

  This function attempts to find the number called <name> relative to
  <looker>. You must control <looker>. This is a bit like the NUM()
  function, but with a wider, controllable "range".

  You can control the preferred type of the match with:
    E   -   Exits
    L   -   Unlocked exits preferred over locked exits
    N   -   No type (this is the default)
    P   -   Players
    R   -   Rooms
    T   -   Things
  If you specify more than one type, the last one will be preferred.

  (Read "help locate2" for more.)

& LOCATE2

  You can control where to look with:
    a   -   Absolute match (look for #<object>)
    e   -   Exits in <looker>'s location
    h   -   "here"  (the location of <looker>)
    i   -   Inventory of <looker>
    m   -   "me"  (<looker> itself)
    n   -   Neighbors (other objects in same location as <looker>)
    p   -   Player names prefixed by '*'
    *   -   All of the above (try a complete match)

Just string all the parameters together, without separating them by
spaces, i.e.  LOCATE(#100, Test, Tn)  would check #100's neighbors
for an object named "Test", preferring a thing over other types.

& BEEP()
  beep(<number>)

  Sends <number> "alert" bell characters. <number> must be in the range
  1 to 5. This function may only be used by wizards.
& SPACE()
  space(<number>)

  Prints <number> number of spaces. Useful for times when you want to
  be able to use lots of spaces to separate things. For example,
  "a[space(5)]b  would print, "Amberyl says, "a     b"".

& LSTATS()
  lstats(<player>)

  This function returns the breakdown of objects in the database, in
  a format similar to "@stats". If <player> is "all", a breakdown is
  done for the entire database. Otherwise, the breakdown is returned
  for that particular player. Only wizards can LSTATS() other players.
  The list returned is in the format:
  <Total objects> <Rooms> <Exits> <Things> <Players> <Garbage>
& STRCAT()
  strcat(<string1>, <string2>)

  Concatanates two strings together, with no space between them.
  For example, strcat(foo bar,baz blech) will return the string
  "foo barbaz blech".

& ABS()
  abs(<number>)

  Returns the absolute value of a number. i.e. ABS(-4) returns 4;
  ABS(2) returns 2, etc.
& SIGN()
  sign(<number>)

  Essentially returns the sign of a number -- 0 if the number is 0,
  1 if the number is positive, and -1 if the number is negative.
  Thus, SIGN(-4) is -1, SIGN(2) is 1, and SIGN(0) is 0.
& ZFUN()
  zfun(<user function name>, <arg 0>, <arg1>, ... <arg8>)

  This is essentially identical to UFUN(), but the attribute corresponding
  to the user function name is read from the ZMO of the object instead
  of from the object itself. In order to read the attribute from the ZMO,
  one of the following criteria must be met:

  1. The object is set WIZARD or ROYALTY.
  2. The object controls the ZMO.
  3. The object's owner owns the attribute on the ZMO.
  4. The ZMO is set VISUAL.
  5. The attribute being checked is set VISUAL.

  See the help for UFUN() for more details on user-defined functions.

& UFUN()
  ufun([<object>/]<user function name>, <arg 0>, <arg1>, ... <arg 8>)

  This allows you to create your own functions and evaluate them.
  <user function name> is the attribute that contains the desired
  user-defined function. Supplying <object> is optional; if you
  do not, the attribute will be read off the object that is
  evaluating the UFUN().

  <arg 0>, <arg 1>, ... <arg 8> are the functions that get passed
  to the user function as v(0), v(1), etc. (as in @trigger).
  You can pass up to 8 arguments. v(9) is always null.

  This function is also known as U()  (alias for 2.0 compatibility).

  See "help UFUN2" for more.

& UFUN2
  Example:

  > @va Object=$test *:"[ufun(testfun, v(0))]; @emit [v(0)]
  > &testfun object=[strlen(v(0))] [ucstr(v(0))]
  > test string
  Foo says, "6 STRING"
  string

  See "help UFUN3" for more.

& UFUN3
  A user-defined function may be as complex as you want it to be.
  If the evaluation order doesn't quite seem right, adding escapes
  or breaking up the expression will probably help.

  Excessive recursion in either a UFUN() or ZFUN() will cause it to
  return "#-1 EXCESSIVE RECURSION ERROR", and sets the object HALT.
  An object which is HALT may not evaluate either UFUN() or ZFUN();
  those functions will then return "#-1 OBJECT HALTED".

& EVAL()
  eval(<object>, <attribute>)

  This function works identically to the XGET function - it retrieves
  <attribute> from <object> - except that it also performs pronoun
  substitution. For example, if something uses "[v(va)]%r[v(vb)]" in
  its description, EVAL() called on that object's desc will evaluate
  the VA and VB attributes correctly, with respect to the object,
  which neither the GET nor XGET do.

& ESCAPE()
  escape(<string>)

  The ESCAPE() function "escapes out" potentially "dangerous" characters,
  preventing function evaluation in the next pass of the parser. It
  returns <string> after adding the escape character ('\') at the
  beginning of the string, and before the following characters:
  %  ;  [  ]  {  }  \

  This function prevents strings entered by players from causing side
  effects, such as performing an unintended GET() of an attribute. It
  is only needed when the resulting string will be passed through @force
  or used as an attribute for an object (like the description of a mail
  message object).  Since the function preserves the original string,
  it is, in most cases, a better choice than SECURE().

& ITER()
  iter(<list>,<pattern>)

  This works in a manner very similar to @map, except that it returns
  a string directly.  <list> is a space-separated list of words, and
  <pattern> is what will be "mapped" onto each element of the list,
  with the token "##" being replaced successively by the next word
  in the list.  The result is concatenated and returned as a space
  separated list.  This is similar to @dolist, but the results are
  made into a list rather than executed.

  See "help ITER2" for some examples.

& ITER2
  Examples:

  > say [iter(This is a test string., [strlen(##)])]
  You say, "4 2 1 4 7"

  > say [iter(lnum(5), mul(add(##,##),2))]
  You say, "0 4 8 12 16"

  > say [iter(lexits(here), [name(##)] (owned by [name(owner(##))]))]
  You say, "South (owned by Claudia) North (owned by Roy)"

  > &STRLEN_FN me=[strlen(%0)]
  > say [iter(This is a test string., [u(STRLEN_FN, ##)])]
  You say, "4 2 1 4 7"

& PMATCH()
  pmatch(<string>)

  Given the partial name of a player, it returns that player's dbref
  number. This partial name completion works identically to the partial
  name completion of the "page" command - i.e. it first attempts to match
  the normal names of all players (connected or not), and if that fails,
  it tries to match the partial names of connected players. If no player
  is matched, it returns "#-1". If more than one match is possible for
  a partial name, it returns "#-2".

& BEFORE()
  before(<string1>, <string2>)

  Returns the portion of <string1> that occurs before <string2>.
  If <string2> isn't in <string1>, <string1> is returned.

  Examples:
   > think before(foo bar baz,bar)
   foo
   > think before(foo bar baz,r)
   foo ba

& AFTER()
  after(<string1>, <string2>)

  Returns the portion of <string1> that occurs after <string2>.
  If <string2> isn't in <string1>, the function returns a null string.

  Examples:
   > think after(foo bar baz,bar)
    baz
   > think after(foo bar baz,ba)
   r baz

& DIE()
  die(<number of times to roll die>, <number of sides on die>)

  This function simulates rolling dice. It "rolls" a die with a given
  number of sides, a certain number of times, and sums the results.
  For example, DIE(2, 6) would roll "2d6" - two six-sided dice,
  generating a result in the range 2-12.
& SECS()
  secs()

  This function takes no arguments, and returns the number of elapsed
  seconds since midnight, January 1, 1970. This is a good way of
  synchronizing things that must run at a certain time.
& SECURE()
  secure(<string>)

  This function returns <string> with all "dangerous" characters replaced
  by spaces. Dangerous characters are ( ) [ ] { } $ % , and ;
  This can make output slightly ugly, but it's a good way of preventing
  other people from doing nasty things with your objects.

  See also:  ESCAPE()

& ZONE()
  zone(<object>)

  Returns the object's 'zone'. This is the dbref of the master object
  which defines the zone.

& LATTR()
  lattr(<object>[/<attribute pattern>])

  Returns a space-separated list of the attribute names on the object.
  You must either be a Wizard or Royalty, own the object, have the
  See_All power, or have the object set VISUAL in order to use this
  function on the object.

  If a wildcarded attribute pattern is provided, only attribute names
  matching that pattern will be returned.

& LSEARCH()
  lsearch(<player>, <class>, <restriction>)

  This function is similar to the @search command, except it returns
  just a list of dbref numbers. It is computationally expensive, and
  costs 100 pennies to perform.
  The function must have three arguments. Wizards can specify "all"
  or <player> for the <player> field; mortals must use "me".
  If you do not want to restrict something, use "none" for <class>
  and/or <restriction>.

  Possible <class>es are TYPE, NAME, ZONE, PARENT EXITS, OBJECTS, ROOMS,
  PLAYERS, and FLAGS. If <class>=TYPE, the possible <restrict>ions are
  OBJECT, ROOMS, EXITS, and PLAYERS. If <class>=NAME, only objects with
  <restriction> whose name matches <restriction> will be listed. If
  <class>=EXITS, OBJECT, ROOMS, or PLAYERS, only objects of that type
  and whose name matches <restriction> will be listed. If <class>=ZONE,
  only objects belonging to the zone <restriction> will be listed. If
  <class>=PARENT, only children of parent <restriction> will be listed.
  For ZONE and PARENT, <restriction> must be specified as a dbref number.
  If <class>=FLAGS, only objects with the list of flags specified by
  <restriction> will be listed. Only wizard and royalty may obtain
  information about other players.

  Examples:
    lsearch(all, flags, Wc)     <-- lists all connected wizards.
    lsearch(me, type, rooms)    <-- lists all rooms owned by me.

& ALPHAMIN()
  alphamin(<word1>, <word2>, <word3>, ...)

  Takes up to ten word arguments, and returns the word which is
  lexicographically smallest.
& ALPHAMAX()
  alphamax(<word1>, <word2>, <word3>, ...)

  Takes up to ten word arguments, and returns the word which is
  lexicographically biggest.
& SORT()
  sort(<word1> <word2> <word3> ...[,<sort type>])

  This sorts a list of words. If no second argument is given, it will
  try to detect the type of sort it should do. If all the words are
  numbers, it will sort them in order of smallest to largest. If all
  the words are dbrefs, it will sort them in order of smallest to
  largest. Otherwise, it will perform a lexicographic sort.

  The following letters as a second argument specify a certain sort:

  'a':  Sort lexicographically.
  'd':  Sort dbrefs.
  'n':  Sort numbers.

& SUBJ()
  subj(<object>)

  Returns the subjective pronoun - he/she/it - for an object.
& OBJ()
  obj(<object>)

  Returns the objective pronoun - him/her/it - for an object.
& POSS()
  poss(<object>)

  Returns the possessive pronoun - his/her/its - for an object.
& TYPE()
  type(<object>)

  This function returns the type of an object - PLAYER, THING, EXIT,
  or ROOM. See "help types of objects" for more.
& RNUM()
  rnum(<room number>, <object>)

  This function returns the dbref number of an object (player, thing, or
  exit). The object must be in the specified room. This function is
  essentially identical to NUM(), except it matches things in the
  specified room rather than the room that you are in. The RNUM()
  function is meant to be used in conjunction with Master Room objects.
& MAX()
  max(<num1>, <num2>, ..., ...)

  This function returns the largest number in its list of arguments.
  It can take up to ten numbers as arguments.
& MIN()
  min(<num1>, <num2>, ..., ...)

  This function returns the smallest number in its list of arguments.
  It can take up to ten numbers as arguments.
& MAIL()
  mail(<mail message #>)
  mail(<player name>)
  mail(<player>, <mail message #>)

  The first form returns a message corresponding to that mail message
  number in your MUSH mailbox. This function can be used to forward
  mail, or as a way to simply transfer mail messages to attributes
  on an object.

  The second form returns two numbers, corresponding to the number of
  read and unread messages <player> has.
  The third form returns <player>'s <mail message #>. It works like
  the first form except it applies to another player.
  Only wizards can use the second and third forms of the function
  on other players.

& XGET()
  xget(<object>, <attribute>)

  This function is identical to get() in purpose, but a comma instead of
  a slash separates object and attribute. There is no real advantage to
  using this instead of get(). Please see "help get()" for more details
  on the use of this function.

& ART()
  art(<string>)

  This function returns the proper article, "a" or "an", based on whether
  or not <string> begins with a vowel.
& LWHO()
  lwho()

  This returns a list of the dbref numbers for all currently-connected
  players. When mortals use this function, the dbref numbers of DARK
  wizards or royalty do NOT appear on the dbref list.
& HASFLAG()
  hasflag(<object>, <flag name>)

  Returns 1 if the object has the named flag, and 0 if it does not.
  You do not have to control the object.
  Example: hasflag(me, connected) will return "1"

  The "flags" ROOM, EXIT, and PLAYER are actually types. If you want
  to check if an object "has" one of these flags, you must use the
  TYPE() function.
& DIST2D()
  dist2d(x1, y1, x2, y2)

  Returns the integer distance between two points in the Cartesian
  plane that have coordinates (x1, y1) and (x2, y2).
& DIST3D()
  dist3d(x1, y1, z1, x2, y2, z2)

  Returns the integer distance between three points in space, with
  coordinates (x1, y1, z1) and (x2, y2, z2).
& WORDPOS()
  wordpos(<string>, <number>)

  Returns the number of the word within <string> where the <number>th
  character falls. Characters and words are numbered starting with 1,
  and spaces between words are treated as belonging to the word that
  follows them. If <number> is not within the string, #-1 is returned.
  Example: wordpos(foo bar baz, 5) returns "2"
& LCSTR()
  lcstr(<string>)

  Returns <string> with all letters converted to lowercase.
  Example: lcstr(Foo BAR bAz) returns "foo bar baz"
& UCSTR()
  ucstr(<string>)

  Returns <string> with all letters converted to uppercase.
  Example: ucstr(Foo BAR baz) returns "FOO BAR BAZ"
& CAPSTR()
  capstr(<string>)

  Returns <string> with the first character capitalized.
  Example: capstr(foo bar baz) returns "Foo bar baz"
& NEARBY()
  nearby(<object 1>, <object 2>)

  Returns 1 if object 1 is "nearby" object 2. "Nearby" is defined as:
  object 1 is in the same location as object 2, or,
  object 1 is being carried by object 2, or,
  object 1 is carrying object 2.
  You must control at least one of the objects.
& FLIP()
  flip(<string>)

  This function reverses a string. For example, "flip(foo bar baz)"
  returns "zab rab oof".
& MONEY()
  money(<object>)

  returns the amount of money <object> has.
& LCON()
  lcon(<object>)

  Returns a list of the dbrefs of all contents in a room that you can
  see. If you are not in the room, you must control it in order to get
  its contents.
& LEXITS()
  lexits(<object>)

  Returns a list of the dbrefs of all the non-dark exits in the room.
  If you are not in the room, you must control it in order to get the
  list of exits.
& WORDS()
  words(<string>)

  words() returns the number of words in a string.
& SUB()
  sub(<num>, <num>)

  Sub() returns the integer subtraction of two numbers.
& LOCK()
  lock(<object>[/<locktype>])

  lock() returns the text string equivalent of the lock on an object that
  you control. You can also provide an "enter", "use", "tport", or "page"
  switch after the object, if you want to check something other than the
  regular lock.
& ELOCK()
  elock(<object>[/<locktype>], <victim>)

  elock() returns 1 if the <victim> would pass the lock on <object>,
  and 0 if it would fail. You do not need to control either object.

  You can also provide an "enter", "use", "tport", or "page" switch
  after the object, if you want to check something other than the
  regular lock.
& GET()
  get(<object>/<attribute>)

  The get function will be replaced by the string stored in the
  attribute of the object. You may get the attributes of objects you
  control, the attributes you control on other objects, and publicly
  accessible attributes.

& TIME()
  time()

  Gives you the current time on the MUSH.
  WARNING!  This is the time on the machine that the mud is running
  on, and not where you are.
& RAND()
  rand(<num>)

  Rand returns an interger between 0 and num-1.
& EXIT()
  exit(<object>)

  Exit returns the first exit on the list of exits in the object.
  Dark exits are not listed.  See Next for the method for seeing the
  rest of the exits in an object.

& ACOS()
  acos(<number>)

  Returns the arc-cosine of <number>, expressed in radians.
& ASIN()
  asin(<number>)

  Returns the arc-sine of <number>, expressed in radians.
& ATAN()
  atan(<number>)

  Returns the arc-tangent of <number>, expressed in radians.
& COS()
  cos(<number>)

  Returns the cosine of <number>, which should be expressed in radians.
& SIN()
  sin(<number>)

  Returns the sine of <number>, which should be expressed in radians.

& TAN()
  tan(<number>)

  Returns the tangent of <number>, which should be expressed in radians.
& E()
  e()

  Returns the value of "e"  (2.718281).
& PI()
  pi()

  Returns the value of "pi" (3.141592).
& FDIV()
  fdiv(<numerator>,<denominator>)

  Returns the quotient of the two numbers. Note that the DIV() and MOD()
  functions cannot be used on floating point numbers.
& EXP()
  exp(<number>)

  Returns e to the power of <number>.
& LOG()
  log(<number>)

  Returns the logarithm (base 10) of <number>.
& LN()
  ln(<number>)

  Returns the natural log of <number>.
& POWER()
  power(<number>,<exponent>)

  Returns <number> to the power of <exponent>.
& CEIL()
  ceil(<number>)

  Returns the least integral value greater than or equal to <number>.
& FLOOR()
  floor(<number>)

  Returns the greatest integral value less than or equal to <number>.
& ROUND()
  round(<number>,<places>)

  Rounds <number> to <places> decimal places. <places> must be between
  0 and 6.

& ADD()
  add(<number>,<number>)

  Returns the sum of two numbers. It operates on integers and floats.
& MUL()
  mul(<number>,<number>)

  Returns the product of two numbers. It operates on integers and floats.
& DIV()
  div(<number>,<number>)

  Div returns the integer quotient of the first number divided by
  the second number.  See MOD.
& MOD()
  mod(<number>,<number>)

  Mod returns the remainder of the interger division of the first
  number by the second.  See DIV.
& LNUM()
  lnum(<number>)

  Lnum returns a list of numbers, from 0 to <number - 1>. For example,
  lnum(4) returns the list "0 1 2 3". This is useful for creating loops.

& FIRST()
  first(<string>)

  Returns the first word of a string, that is, everything to the left
  of the first space in the string, or the entire string if there are
  no spaces in the string.  See REST.
& REST()
  rest(<string>)

  Rest takes a string, returns all the string except the first word,
  that is, everything to the right of the first space, or an empty
  string, or the empty string if there are no spaces in the string.
  See FIRST.
& STRLEN()
  strlen(<string>)

  Returns the length of the string in a numerical string.
& MID()
  mid(<string>, <first>, <length>)

  Mid returns a segment of the string, the <length> characters to the
  right of the <first> character.  Note that the first character in a
  string is numbered zero, and not one.
& COMP()
  comp(<string1>, <string2>)

  Comp compares two strings.  It returns 0 if they are the same, 1 if
  string2 is less than/preceeds alphabetically string2, and -1
  otherwise.
& S-FUNCTION
  s(string)

  This function performs pronoun substitution in a string, and then
  returns that string.  As usual, %n is the name, %s the subjective
  pronoun, %o the objective, and %p the possessive.  It is important
  to note that the pronoun is that of the triggering object.

  So, if the ve of an object were: "[s(This is %n)], and I were to
  type @trigger <object>/ve, it would return "This is <myname>", but
  if vf were @trigger me/ve, then triggering the vf makes the ve
  return "This is <object>"

& POS()
  pos(<string1>,<string2>)

  This function returns the position that string1 begins in string2,
  with the first position being 1.
  If string1 is not in string2, then it returns -1.
& MATCH()
  match(<string>, <pattern>)

  This function tests if the pattern matches the string.  The pattern
  can contain the wildcards * and  ?.  ? matches to any one
  character, while * matches to any number of characters, including
  none.  So s?x would match to sex or six, but not to socx, but s*x
  would match to all of them. If no match is found, 0 is returned.

  This attempts to match to a word, not to an entire string. To match
  an entire string  (for example, to match "red blue green" to "*bl*"),
  use the strmatch() function.

& STRMATCH()
  strmatch(<string>, <pattern>)

  This function is matches <pattern> against the entire <string>.
  It returns 1 if it matches and 0 if it doesn't. It is not
  case-sensitive, and <pattern> may contain wildcards.

  strmatch(Foo bar baz,*Baz) will return 1.
  strmatch(Foo bar baz,*Foo) will return 0.
  strmatch(Foo bar baz,*o*a*) will return 1.

& EXTRACT()
  extract(<string>,<first>,<length>)

  Extract returns a string of length words, starting with the first
  word. Unlike letters, the first word in a string is number 1,
  instead of 0.

  A word is assumed to be defined as a string beginning and ending
  with a space, or a string w/o any interior spaces.
& FLAGS()
  flags(<object>)

  Flags returns a string consisting of the flags attached to the
  object. The string is, however, just one word.
& NUM()
  num(<object>)

  Returns the dbref number of the object, which must be in the same
  room as the object executing num.
& CON()
  con(<object>)

  Con returns the first object in the list of objects carried by
  thing. Just the first, and only the first.  See NEXT.
& LOC()
  loc(<object>)

  Loc returns the dbref of the location that object is at.  The
  object has to either be yours or be in the same room as you to
  work. The location of an exit is its destination (the source of
  an exit is its home). The location of a room is its drop-to
  (if one is not set, then the location is #-1).

& WHERE()
  where(<object>)

  This function returns the "true" location of an object. This is
  the standard location (i.e. where the object is) for things and
  players, the source room for exits, and #-1 for rooms.

  In other words, the "true" location of an object is where it is
  linked into the database. For example, an exit appears in the
  room of its "home", not its "location" (the LOC() function on an
  exit will return the latter). A room's "real" location is always
  Nothing (the LOC() function will return its drop-to).

& OWNER()
  owner(<object>)

  Owner returns the dbref of the owner of the object.  The object
  has to either be yours or else be in the same room as you.
& NAME()
  name(<dbref>)

  Name returns the name of object (dbref).
& NEXT()
  next(<thing>)

  If thing is an exit in a room, then next will return the next
  nondark exit in the list of exits for that room.  If thing is an
  object, then next will return the next oject in the inventory list
  that the object is in.  Otherwise, it returns a '#-1' string.
& @ps
  @ps [/<switch>] [*<player> | all | count ]
  @ps is a useful command for MUSHers.  It lists all commands
  currently on your 'to be executed' queue, thus allowing you to
  identify infinite (or unnecessary) loops with-out putting in says
  or poses. It gives a count of the total commands in each of the
  queues (Player, Object, Wait, and Semaphore), displayed in the format
  <Number of your queued commands> / <Total number of queued commands>.
  @ps can identify that you actually *do* have an infinite loop.  Much
  better than waking up in the morning with all your money gone!

  @ps with no arguments will show you your own queue. Wizards may
  specify the /all switch or option, and see the full queue. They
  may also specify a player.
  @ps/summary or the "count" option just displays the queue totals.
& Looping
  Looping in an object can have it's good parts and it's bad parts.
  The good part is when you activate part of a program multiple times
  to exhaustively perform an operation.  This is usually done by:
  va: <list of commands>;@trigger me/vb
  vb: @switch <test> = <false>,@trigger me/va,<otherwise go on>
  Looping can be a problem when it goes on without stopping.  The @ps
  command can be used to see if you are looping.  Beware!  A looping
  machine that isn't @halt'd will drain your pennies while you are away
  from the mush!
  See @ps.
& enter
  enter <object> can be used to enter the inside of an object.
  Insides of objects are best used for vehicles, or storage spaces
  when you don't have a home.  (or even a floating home)  Note that
  you can enter only objects you own or that have the Enter_ok flag
  set.
  (see @enter, @oenter, @aenter, leave, @lock, and @idesc)
& @enter
  @enter <object> = <message>
  Basically the @succ for the 'enter <object>' exit.  The message is
  displayed to anyone entering the object.
& @leave
  @leave <object> = <message>
  Basically the @succ for the 'leave <object>' exit.  The message is
  displayed to anyone leaving the object.
& @oenter
  @oenter <object> = <message>
  Similarly to other omessages, this displays <name> <message> to
  everyone inside the object, except for the person who is entering.
& @oleave
  @oleave <object> = <message>
  Similarly to other omessages, this displays <name> <message> to
  everyone inside the object, except for the person who is leaving.
& @aenter
  @aenter <object> = <actionlist>
  Executes <actionlist> whenever someone enters the object.  Actions
  are lists of commands separated by semi-colons and these commands
  are executed by the object (see puppet). Objects can execute almost
  any command.  Gender substitutions are applied to the commands
  before they are executed, which allows use of the player's name who
  caused the action.  See @enter, and @oenter.
& @aleave
  @aleave <object> = <actionlist>
  Executes <actionlist> whenever someone leaves the object. Actions
  are lists of commands separated by semi-colons and these commands
  are executed by the object. (see puppet). Objects can execute almost
  any command.  Gender substitutions are are applied to the commands
  before they are executed, which allows use of the player's name who
  cause the action. See @leave and @oleave.
& @oxenter
  @oxenter <object> = <message>
  This replaces the functionality of the old @oenter.  This message is
  shown to everyone in the room that the player leaves whenever he enters
  an object via the command 'enter <object>'. This will be shown in
  addition to the leave message of the room, not instead of.
& @oxleave
  @oxleave <object> = <message>
  This message is shown to everyone in the room that a person enters
  when doing a 'leave' command.  This will be shown in addition to the
  enter messages of the room, not instead of.
& BOOLEAN VALUES
  Boolean values are internally considered to be either 1, generally
  interpreted as being true, and 0, which is generally interpreted as
  being false. Now, any string is interpreted as true(1), except for
  the null string (whose length is 0), which is false(0).
  A #-1 is interpreted as false(0), and any other #<dbref> is
  interpreted as true(1).  Any number except 0 is interpreted as
  true(1), except 0 which is false(0).
  (Yes, even negative numbers are true(1))

  Examples:
  not(foo) = 0
  not(<null string>) = 1
  not(-66) = 0
  not(0) = 1
  not(#-1) = 1
  not(#12) = 0
  And so on...
  (note: These rules only apply when a function expects a Boolean
  value, not for strings that expect other values.)
& AND()
  [AND(<boolean value>,<boolean value>)]

  Takes two booleans, and returns 1 is the two boolean values are
  each equivalent to true(1).  See BOOLEAN VALUES.
& OR()
  [or(<boolean value>,<boolean value>)]

  Takes two booleans, and returns a 1 if at least one of the inputs
  is equivalent to true(1).  See BOOLEAN VALUES.
& NOT()
  [not(<boolean value>)]

  Takes a boolean value, and returns it's inverse.
  I.E. if the input is equivalent to true(1), it returns a 0, and if
  the input is equivalent to false(0), it returns a 1.
  See BOOLEAN VALUES.
& XOR()
  [xor(<boolean value>,<boolean value>)]

  Takes two booleans, and returns a 1 if one, and only one of the two
  inputs is equivalent to true(1).  See BOOLEAN VALUES.
& gt()
  [gt(<integer1>,<integer2>)]

  Takes two integers, and returns 1 if and only if
  integer1 > integer2, and 0 otherwise.
& gte()
  [gte(<integer1>,<integer2>)]

  Takes two integers, and returns 1 if and only if
  integer1 >= integer2, and 0 otherwise.

& lt()
  [lt(<integer1>,<integer2>)]

  Takes two integers, and returns 1 if and only if
  integer1 < integer2, and 0 otherwise.
& lte()
  [lte(<integer1>,<integer2>)]

  Takes two integers, and returns 1 if and only if
  integer1 <= integer2, and 0 otherwise.
& eq()
  [eq(<integer1>,<integer2>)]

  Takes two integers, and returns 1 if they
  are equal, 0 otherwise.
& neq()
  [neq(<integer1>,<integer2>)]

  Basically the same as [not(eq(<integer1>,<integer2>))].
  (see eq(), not())
& cat()
  cat(<string1>,<string2>[,<string3>,<string4>,...])

  cat() concatenates strings, separating each string by a space.
  So "[cat(one, two)]" will return 'one two'.
& member()
  [member(<list>,<word>)]

  Member takes a list and a word, and returns the position of <word>
  if <word> is a word in <list>.  A word is defined as a string which
  has no interior spaces.  So '  hello  ' would be one word, while
  'hello there' would be two.  See LISTS
& LISTS
  A list is a string, usually stored in an attribute (currently any
  of the va-vz's), which is a series of words, separated by one or
  more spaces.  The following would be a list
  (denoted on the ends by ', which is not actually in the string):
  'one two three four five'
  The functions first(), rest(), cat(), member(), remove(), all work
  on lists.  Look them up, they can be very helpful.
& leave
  The command leave allows you to exit an object you have enter'ed
  into. There is not way to stop someone from leaving an object once
  they get inside it, and there is not any oenter or enter messages
  that get triggered.
  See enter, enter_ok.
& remove()
  [remove(<list>,<word>)]

  Remove takes a list and a word, and returns the list, with the
  word deleted from it.  A word is defined as a string which contains
  no interior spaces.  If the word is not in the list, then the list
  is returned.
& RWHO
  RWHO  This MUSH may be attached to the RWHO server that was created
  by Marcus Ranum (Jerry_Cornelius).  Every so often, the MUSH sends
  out information about who is logged in to this server.  The RWHO
  command is an internal client that talks to this server.  Most MUSHes
  might not have this command even if they actually send information to
  an RWHO server.  The reason that PernMUSH has this in-game is because
  there is also an RWHO server on the same machine.  If it was on a
  separate machine, network problems could freeze the mud.
& @remit
  @remit <object> = <message>.  Sends the message to all contents of
  <object>, which can be a room, thing, or player. (The TinyMUSH 2.0
  equivalent is @pemit/contents).
  See also @emit, @pemit, @oemit, SPOOFING, NOSPOOF and CONTROL.
& @oemit
  @oemit [<room>/]<object> = <message>

  If no room is specified, this command shows <message> to everyone
  in your current location EXCEPT <object>.

  If a room is specified (usually via dbref), this command shows
  <message> to everyone in <room> except for <object>. In this case,
  <object> is matched with reference to <room>. Therefore, if you
  want to send a message to everything but an object called "spy"
  in #100, you can simply use "@oemit #100/spy=Test"; you don't need
  to know the dbref of "spy".

  See also: @emit, @pemit, NOSPOOF and SPOOFING.
& @hide
  @hide[/<switch>]

  This command enables a royalty, wizard, or player with the Hide
  power to disappear from the WHO list for mortals. "@hide/yes"
  hides the player, "@hide/no" unhides the player. Setting and
  unsetting the DARK flag automatically hides and unhides a player,
  but using the @hide command does not affect the DARK flag. Hidden
  players are marked as "(Dark)" in the privileged WHO listing.

  Hidden players also disappear from the RWHO, and mortals cannot
  use the CONN(), IDLE(), or LWHO() functions to find them.

& @halt
  @halt <object>  or  @halt <object>=<new_command> or @halt/all

  This command removes all queued actions in all queues for <object>,
  and, if <new_command> is specified, places that new command in the
  queue. If <object> is a player, it clears the queue for the player
  and all of his objects. You can use "@halt me" to clear your own
  queue. The /all switch makes this command equivalent to "@allhalt".
  If no new command is given and the object being halted is not a
  player, the object is also set HALT.

  Note that halting an object does NOT affect any objects waiting
  on it as a semaphore.

& @allhalt
  @allhalt.  This commands halts all objects in the game in an effort to
  free up the queue.  This is a wizard only command. Objects set
  IMMORTAL are immune to the effects of an @allhalt.
  This command is equivalent to "@halt/all".
& @chownall
  @chownall <player> [= <target_player>].  Tranfers ownership of all items
  that player owns (except player) to the ownership of target_player.
  This is a wizard only command.  If target_player is not given, the
  executing recipient is the subject of the @chownall.
& @doing
  @doing [/header] <message>.  If this is compiled in you can set a short
  message that will show up in the WHO listing next to your name.
  The /header switch is equivalent to "@poll", and sets the header at
  the top of the WHO listing. This switch can only be used by wizards.
& @motd
  @motd [/<switch>] [<message>].

  The default for this command (and with the /connect) switch, is a
  wizard only command that will set a short (non-longterm) message that
  will be shown to players when they connect.

  Other switches:
  /wizard : sets the message for wizards (like @wizmotd)
  /down   : sets the logins-off message (like @rejectmotd)
  /full   : sets the max-players-logged-in message
  /list   : list the MOTDs (like @listmotd, can be used by anyone)
& @wizmotd
  @wizmotd <message>.  This is a wizard only command that will set a short
  (non-longterm) message that will be shown to wizards when they connect.
& @rejectmotd
  @rejectmotd <message>.  This is a wizard only command that will set a
  short (non-longterm) message that will be shown to players that try to
  connect when logins are disabled.
& @listmotd
  @listmotd.  This is a wizard only command that will display the current
  motd, wizmotd and rejectmotd to the player.
& @poor
  @poor <value>.
  This is a wizard only command.  It sets every player's money supply to
  value
& @power
  @power <object>=[!]<power>

  This is a wizard-only command which allows the granting of special
  priviledges to objects of any type.

  A list of powers is given in "help powers list".
& POWERS LIST
  Powers List:

  boot            Can use @boot command.
  builder               Can use Builder commands.
  chat_privs        Can use Admin channels.
  halt            Can @halt others' objects and do @allhalt.
  hide            Can hide on the WHO list.
  idle            No inactivity timeout.
  immortal        Doesn't need money or quota, and can't be killed.
  login            Not subject to login restrictions.
  long_fingers         Can do things remotely, like "get".
  poll            Can use @poll command.
  player_create        Can use @pcreate command.
  queue            Has 10x normal queue limit.
  quota            Can use @quota commands on other players.
  search        Can do @search, @stats, and @entrances on anything.
  see_all        Sees everything as if it were Visual.
  see_queue             Can do @ps on anyone, and @ps/all.
  tport_anything        Can @teleport anything.
  tport_anywhere    Can @teleport to anywhere.
& @entrances
  @entrances[/<switch>] <object> [=<begin>,<end>]

  This command will show you all exits linked to the object you use the
  command on, as well as where the exit originates.  This command is
  computationally expensive and costs the same as @find. You can limit
  the range of the dbrefs searched by specifying <begin> and <end>.

  It takes four switches:

  /exits       show only exits linked to <object>
  /things      show only things which have their homes in <object>
  /players     show only players who have their homes in <object>
  /rooms       show only rooms which have a drop-to of <object>

& @atrlock
  @atrlock <object>/<attribute> = [on|off].
  If 'on' is specified, it 'locks' the specified attribute on the object
  if it is unlocked already.  If the attribute is unlocked, and owned by
  someone other than you, you will gain ownership of it.  If an attribute
  is unlocked, then anyone who controls the object or the person who
  controls the attribute may change it.  Wizards may lock/unlock anyones
  attributes (but will not transfer ownership).  If you specify 'off' it
  will unlock a locked attribute. Specifying neither will return the
  current value of the lock.
& @atrchown
  @atrchown <object>/<attribute> = <new_owner>.
  Like @chown except it changes the control of an attribute from one person
  to another.. You may only @atrchown attributes that you currently own.
& @allquota
  @allquota <limit>
  This is a wizard level command that is only available if the quota
  system is being used.  It displays the current max and owned objects
  of every player and resets their quota left to the new limit minus the
  current number owned.
& @disable
  See '@enable'.
& @enable
  @enable <parameter>
  @disable <parameter>

  These are wizard commands that allow certain parameters of the game to
  be changed at runtime. The values of these parameters are listed by the
  "@config/globals" command. Parameters and their effects are as follows:

  logins       --  When logins are disabled, only wizards and royalty may
                   log into the game. Mortals attempting to log in will be
                   given the down text, as well as the @rejectmotd.
  daytime      --  When daytime is enabled, computationally expensive commands
                   cannot be run. @find, @search, @entrances, LSEARCH(), and
                   @dump cannot be used, although the automatic database save
                   routines will continue to run.
  command_log  --  When this is enabled, all commands are logged.
  huh_log      --  When this is enabled, all commands that produce a "Huh?"
                   are logged.
  force_log    --  When this is enabled, @forces done by wizards are logged.
  wall_log     --  When this is enabled, @wizwalls are logged.

& @dbck
  @dbck
  This is a wizard only command.  It forces the database to do run
  the internal cleanup and consistency check that normally runs about
  every 10 minutes or so. (This command implies @purge)
& @dump
  @dump [/paranoid] [check interval]

  This is a wizard only command that saves a copy of the current memory
  database out to a save file.  This preempts the normal regular dumping
  that the mud performs on its own.

  If the /paranoid switch is used, the game performs additional consistency
  checking which corrects possible data corruption. If a check interval
  is specified, the game writes confirmation of the dump to the checkpoint
  log file every <interval> objects. If no interval is specified, it is
  taken to be the size of the databased, divided by 5.
  This switch should ONLY be used if a normal @dump is not being done
  correctly. Paranoid dumps should generally only be done by wizards with
  access to the account on which the MUSH is running, since others will
  not have access to the checkpoint logfile.

& @pcreate
  @pcreate <name> = <password>
  This is a wizard level command that is only available if registration is
  being enforced.  It creates a player with the given name and password.
& @purge
  @purge
  This is a wizard only command that will check the destroyed object list
  for corruption, and make sure that all objects there are really there.
& @quota
  @quota [/<switch>] <victim>
  This is a wizard level command that is only available if the quota
  system is enabled.  It reports the victim's owned objects and the
  maximum number of objects he may own.
  The /set and /all switches are equivalent to @squota and @allquota,
  respectively.
& @squota
  @squota <victim> = <limit>
  This is a wizard level command that is only available if the quota
  system is enabled.  It reports the victim's owned objects, and sets
  the maximum number of objects he may own to <limit>. If no limit is
  specified, this works identically to @quota.
& @toad
  @toad <player>
  This is a wizard only command.  It changes a player into an object, and
  @chowns all of the previous players possessions over to the @toading
  wizard.
& @uptime
  @uptime

  This command, for mortals, gives the time until the next database dump.
  For wizards, it also gives the system uptime (just as if 'uptime' had
  been typed at the shell prompt) and process statistics: the process ID,
  the machine page size, the maximum resident set size utilized (in K),
  "integral" memory (in K x seconds-of-execution), the number of page
  faults ("hard" ones require I/O activity, "soft" ones do not), the
  number of times the process was "swapped" out of main memory, the
  number of times the process had to perform disk I/O, the number of
  network packets sent and received, the number of context switches,
  and the number of signals delivered to the process.
  In addition, this command gives wizards the dbref number of the first
  object in the destroyed object free list.

& @version
  @version
  Tells the player the name of the MUSH, which version of the code is
  currently running on the system, when it was compiled, and when
  the last restart was.
& @verb
  @verb <victim>=<actor>,<what>,<whatd>,<owhat>,<owhatd>,<awhat>,<args>

  This command provides a way to do user-defined verbs with associated
  @attr/@oattr/@aattr groups. Invoking it does the following:

  <actor> sees the contents of <victim>'s <what> attribute, or
    <whatd> if <victim> doesn't have a <what>.
  Everyone in the same room as <actor> sees the contents of
    <victim>'s <owhat> attribute, with <actor>'s name prepended,
    or <owhatd>, also with <actor>'s name prepended, if <victim>
    doesn't have an <owhat>.
  <victim> executes the contents of his <awhat> attribute.

  By supplying up to nine <args>, you may pass those values on
  the stack (i.e. %0, %1, %2, etc. up through %9).

  See "help @verb2" for more.

& @verb2
  In order to use this command, at least one of the following criterion
  must apply:
    1. The object which did the @verb is a wizard.
    2. The object which did the @verb controls both <actor> and <victim>
    3. The thing which triggered the @verb (such as through a $command on
       the object which did the @verb) must be <actor>, AND the object
       which did the @verb must be either priviledged or control <victim>
       or <victim> must be VISUAL.

  See "help @verb3" for examples.

& @verb3
  Examples:

  > @va test = $frob test:@verb me = %N,FROB,You frobbed test!,OFROB,
               frobbed test!,AFROB
  test - Set.
  > frob test
  You frobbed test!
  [ everyone in the same room sees ] Wizard frobbed test!
  > &FROB test=Nifty. You frobbed test.
  test - Set.
  > &OFROB test=frobbed test, cool.
  test - Set.
  > &AFROB test=:is frobbed!
  > frob test
  Nifty, You frobbed test.
  [ everyone in the same room sees ] Wizard frobbed test, cool.
  test is frobbed!

  Another example follows in "help @verb4"

& @verb4
  If we want to make the "frob" command global and usable for anything,
  we'll need to put the verb definition on a wizard object in the Master
  Room. The following (simplified) command would be the easiest way
  to accomplish this.

  &DO_FROB Global = $frob *:@switch [locate(v(#),v(0),n)]=#-1,
                    {@pemit %#=I don't see that here.},
                    {@verb [locate(v(#),v(0),n)]=v(#),FROB,
                     You frob [capstr(v(0))]!,OFROB,
                     frobs [capstr(v(0))]!,AFROB

  Anyone typing "frob <random object>" would trigger off the approrpiate
  attributes, if they are set on <random object>, or the default messages,
  if not.

& @wait
  @wait <time> = <command_list>
  @wait <object> = <command_list>
  @wait <object>/<time> = <command_list>

  The basic form of this command puts the command list (a semicolon-separated
  list of commands) into the wait queue to execute in <time> seconds.

  The second form sets up a semaphore wait on <object>. The enactor will
  execute <command_list> when <object> is @notified.

  The third form combines the first two: the enactor will execute
  <command_list> when <object> is @notified or when <time> passes,
  whichever happens first.

  See also the help for: SEMAPHORES, @drain, @notify
& @drain
  @drain <object>

  This command discards all commands waiting on the semaphore <object>
  and resets the semaphore to its initial state (clearing the SEMAPHORE
  attribute). The pending commands are removed from the queue without
  being executed.

  See also the help for: SEMAPHORES, @notify, @wait
& @notify
  @notify[/all] <object>[=<count>]

  This command notifies the semaphore <object>, running the first
  command that waited on <object> using the semaphore version of
  @wait. If <count> is specified, it notifies the semaphore that
  many times. If there are no commands, or less than <count>
  commands, pending for <object>, then subsequent @waits will not
  block until the semaphore count reaches zero again.

  The "/all" switch to this command notifies the semaphore until
  the semaphore count is exactly zero; all commands pending on that
  semaphore are executed immediately. <count> is ignored.

& @adisconnect
  @adisconnect <object> = <command-list>
  Sets the actions to be taken by a player right after disconnecting from
  the game.
  This attribute is only meaningful for players, and will never be
  automatically triggered on other object types.
  Example: @adisconnect me = home
  It is also possible to check the zone object/objects in the zone parent
  room, as well as objects in the master room, for an @adisconnect. If one is
  found, it will be executed when a player disconnects in that zone (or,
  in the case of the master room, anywhere).
  See also: @aconnect.
& @aconnect
  @aconnect <object> = <command-list>
  Sets the actions to be taken by a player right after connecting to the
  game.  This attribute is only meaningful for players, and will never be
  automatically triggered on other object types.
  Example: @aconnect me = :stretches luxuriously, as if waking from a nap.
  It is also possible to check the zone object/objects in the zone parent
  room, as well as objects in the master room, for an @aconnect. If one is
  found, it will be executed when a player connects in that zone (or, in
  the case of the master room, anywhere).
  See also: @adisconnect.
& @lemit
  @lemit <message>

  Emits a message to the outermost container object. For example, if you
  are carrying a bird, and are inside a vehicle which is in room #10, and
  you force the bird to @lemit "Cheep", everyone in room #10 will hear
  "Cheep". This command is the same as "@emit/room".
& @zemit
  @zemit <zone> = <message>

  Emits a message to all rooms in <zone>. You must have control in that
  zone in order to use this command. Because it is computationally
  expensive, it costs 100 pennies.
& think
  think <message>

  You can use this command to send a private message to yourself. Pronoun
  substitution is performed. This is essentially equivalent to doing a
  "@pemit me=<message>", but with "think", there's no prepended text.
  One possible use: @adesc me=think %N just looked at you.

& @wallpose
  @wallpose <pose>

  Sends a pose to all connected players. This command may be abbreviated to
  "@wall :<pose>". It is only executable by wizards.
& @wallemit
  @wallemit <message>

  Sends an emit to all connected players. It is only executable by wizards.
& @decompile
  @decompile <object>

  This dumps the sequence of commands needed to recreate that object. It
  is useful for keeping off-MUSH records of your valuable objects, and for
  transferring code from one MUSH to another. Normal locks and enter locks
  are decompiled, but attributes are not shown as locks.
& @move
  @move <object> = <movement message>

  This attribute stores the message shown to the object when the object moves.
& @omove
  @omove <object> = <message>

  This is a member of the family of o-messages. This is shown to the contents
  of the location that the object moves to.
& @amove
  @amove <object> = <action>

  This is the action to be taken whenever an object moves.

& @prefix
  @prefix <object> = <message>

  This attribute is meant to be used in conjunction with the AUDIBLE
  flag. The @prefix of the object is prepended to messages propagated
  via AUDIBLE.   Pronoun substitution is done on @prefix messages.

  For example, if you have an audible exit "Outside" leading from a room
  Garden to a room Street, with @prefix  "From the garden nearby,"  if
  Joe does a ":waves to everyone." from the Garden, the people at Street
  will see the message,   "From the garden nearby, Joe waves to everyone."

& @filter
  @filter <object> = <pattern 1>, <pattern 2>, <pattern 3>, ...

  This attribute is meant to be used in conjunction with the AUDIBLE
  flag. The @filter of an object is a comma-separated list of wildcard
  patterns (like @switch patterns). Any messages which match one of the
  patterns is suppressed and not propagated through the AUDIBLE object
  with the @filter set. (Note: @filter on rooms has no effect!)

  See 'help @filter2' for examples.

& @filter2

  Example:  in a room with the audible exit "Outside" which leads to
  a room where a puppet "Wiztoy" is listening, with exit @prefix
  "From inside," and @filter "Testing *,Puppet *":

  > :tests.
  One tests.
  Wiztoy> From inside, One tests.
  > @emit Testing @filter.
  Testing @filter.
  > @emit Test.
  Test.
  Wiztoy> From inside, Test.
  > @emit Puppet waves.
  Puppet waves.

& @inprefix
  @inprefix <object> = <message>

  @inprefix is intended for use with objects with a @listen of "*".
  It prepends the <message> string to any message propagated to the
  contents of <object> from the outside. If there is no @inprefix,
  no string is prepended to the output.

  Example:

    [ First, @create Vehicle and Test (objects #103 and #104) and drop them ]

    > @inprefix Vehicle = From outside,
    Vehicle - Set.
    > enter Vehicle
    Vehicle(#103)
    > @force #104=:bounces.
    From outside, Test bounces.

& @infilter
  @infilter <object> = <pattern 1>, <pattern 2>, <pattern 3>, ...

  @infilter is meant to be used in conjunction with objects that have
  a @listen of "*". It can be used to prevent certain messages from
  propagating to the object's contents from the outside; message patterns
  that match one of the @infilter patterns are suppressed.

  For an explanation of these patterns, see the help for "@filter".

& @chat
  @chat <channel> = <message>

  This tells everyone on <channel> your <message>. You can prepend
  <message> with ':' or ';' to pose instead of talk. This command can
  also be formatted:  +<channel> <message>
  You do not need to type the complete name of the channel, only as
  many letters as needed to make it distinct from another channel.

  Note: if you use the '+' form of this command, and you do not
  use the name of a known channel, your command will be processed
  as normal, preventing user-defined commands like "+last" from
  being clobbered by the chat system.

& @channel
  @channel <channel> = <on | off | who>

  The basic form of this command allows you to join, leave, or see who
  is on a certain channel. (Read "help @channel2" for help on extensions
  and additional switches to this command). You do not need to type the
  complete name of the channel, only as many letters as needed to make it
  distinct from another channel.

  You may use command switches with @channel:
  "@channel/on public" is equivalent to "@channel public=on"
  Some channels may be restricted to administrators or wizards only.
  If you do not have the priviledges needed for that channel, you will
  not be able to see who is on it.

  More details are provided in "help @channel2".

& @channel2
  @channel/list
  @channel/add <channel> = <priv level>
  @channel/delete <channel>
  @channel/name <channel> = <new name>
  @channel/priv <channel> = <new priv level>
  @channel/wipe <channel>

  These four switches to @channel provide extensions to the basic chat
  system. Only the "list" switch may be used by non-Wizards; it lists
  all existing chat channels.

  The "add" switch allows a wizard to add a new channel. The possible
  priv levels are "public", "admin", "wizard", and "forbidden". They
  allow access to everyone, royalty, wizards, and nobody, respectively.
  A channel name must be unique; you should not have two channels called
  "Chat1" and "Chat2", for example.

  The "delete" switch removes an existing channel. The "name" and "priv"
  switches changed the channel name and priviledge level, respectively.
  The "wipe" switch clears a channel of players without deleting it.

& CHAT
  CHAT SYSTEM

  The MUSH has a built-in chat system with many different channels.
  These channels vary from MUSH to MUSH; ask at your local site about
  which ones are available. The "Public" channel is normally available.

  You can talk to many people on the MUSH via the chat system, without
  needing to be in the same room as them. Use the "@channel" command
  to join, leave, or check who is on a channel, and use the "@chat"
  or "+" command to communicate.

  If you examine yourself, you will see a list of channels that you are
  currently listening to. Some channels are restricted to wizards or
  administrators only. See the help for "@chat" and "@channel" for more.

& @@

  The "@@" command is a special kind of command; it signals the start
  of a comment. The comment lasts until a semi-colon is found, just
  like other MUSH programming statements terminate with a semi-colon.
  It cannot be put into the middle of a statement, like
  @va me = $testing:@emit Test. @@ Just a test @@; @vb me=Testing.
  That will result in the object emitting "Test. @@ Just a test. @@"
  The correct usage is to make the comment a statement by itself:
  @va me = $testing:@emit Test.; @@ Just a test @@; @vb me=Testing.

  It is not necessary to use a closing '@@', but doing so makes the
  comment stand out much more clearly. A space between the first
  '@@' and the word following it is not necessary.

& @wipe
  @wipe <object>

  This command clears all attributes from <object>, with the exception of
  attributes changeable only by wizards, and attributes not controlled by
  the object's owner (i.e. locked attributes owned by someone else).
  Only God may use @wipe to clear wiz-changeable-only attributes.
  The SAFE flag protects objects from @wipe.

& @parent
  @parent <object> = <parent>

  This command sets the parent of <object> to <parent>. <parent> may be
  an object of any type; <object> can be anything but a player. The
  player must control <object>. <parent> must either be owned by the
  player, or LINK_OK, or the player must be a wizard.
  If <parent> is "none" or blank, the object is unparented.

& rpage
  rpage[/<switch>] <player>@<MUSHname> = <message>

  This command allows you to remote-page a player connected to another
  MUSH. <Message> may be either text or a pose, and is formatted accordingly.
  The MUSH you are trying to page to must be registered with the MUSH
  you are on  (they must know each other's names and rpage passwords;
  talk to the Gods if they aren't).

  A remote-page message is prepended with the name of the originating
  MUSH, in curly braces. When you attempt to remote-page someone, you
  are not guaranteed to be able to contact the other MUSH; unless you
  get your message echoed back, you cannot be sure that the remote
  player received your message. He might have, but then again, he might
  not have.  The remote-page facility uses UDP datagrams, and thus does
  not guarantee transmission.

  Read 'help rpage2' for more.

& rpage2
  Example:  Amberyl, on TinyKrynn, wishes to page Polgara, on Belgariad.

    Amberyl types:  rpage Polgara@Belgariad = Hi there.
    Polgara sees:  {TinyKrynn} Amberyl pages, 'Hi there.'
    Amberyl sees:  {Belgariad} To Polgara: Amberyl pages, 'Hi there.'

    Polgara replies:  rpage Amberyl@TinyKrynn =:waves hello.
    Amberyl sees:  {Belgariad} Polgara waves hello.
    Polgara sees:  {TinyKrynn} To Amberyl: Polgara waves hello.

  Read 'help rpage3' for more.

& rpage3

  If the other person is not connected, is set HAVEN, or doesn't exist,
  the person attempting to page will receive an error message.

  If the person attempting to page receives no message of acknowledgement
  other than "Done.", it is likely that the message hasn't gotten through.
  Often, though, a few seconds will pass between the "Done."  message and
  the acknolwedgement.

  Please note that the names of the MUSHes are case-sensitive. You need
  to make sure that the name of the MUSH you are typing appears in the
  remote-page connection list, accessed by typing "rpage/list".

  Read 'help rpage4' for more.

& rpage4

  The rpage command takes two additional switches, "add" and "delete",
  which are restricted to God only.

  To add a new server: rpage/add <Name of server> <Password> = <Address>
  For every server you are "connected" to, you must have one entry which
  has the full name of the MUSH, as used in @version on that MUSH. This
  is the "identifying" entry. Both your MUSH and the other MUSH need to
  share a password.
  FooMUSH:  rpage/add BazMUSH foobar=bazvax.cowtech.edu
  BazMUSH:  rpage/add FooMUSH foobar=foovax.cowtech.edu

  You can have multiple entries for the same MUSH, i.e. you could also do:
  rpage/add Foo foobar=foovax.cowtech.edu

  Deleting a server entry is simple: rpage/delete <Name of server entry>

  Server entries are automatically saved when the database is.

& COPYRIGHT
  Any use of this help text must contain this copyright notice.
  This help text was written by Jin, Moonchilde, Leona, and Amberyl,
  for TinyMUSH 1.0, PernMUSH 1.02 - 1.15, and PennMUSH 1.16 on,
  respectively.

& CREDITS

  The original TinyMUSH 1.0 code was written by Lawrence Foard, and
  was based upon James Aspnes' TinyMUD server. Since then, the code
  has been modified by the programmers of MicroMUSE (then MicroMUSH),
  and Joseph Traub (Moonchilde of PernMUSH).

  Since January of 1992, Lydia Leong (Amberyl of PernMUSH / Polgara
  of Belgariad) has been maintaining the code currently know as
  PennMUSH 1.50.

  Additional credits go to:
    Ambar (PernMUSH):  debugging and lots of other stuff (PernMUSH v1.14)
    Annalyn (PernMUSH): lots of code ideas, algorithms, general help
    Javelin and Talek: (Belgariad): lots of ideas for various things
    Delta (Twilight), Jim Miller: some portability tweaks and error fixing
    Durnik, Shaav, Varana, Henrik, and other Belgariad players: playtesting
  ... plus the TinyMUSH 2.0 mushhacks and the myriad people using this server.